Remove docs. "lynxkite.core" is now "lynxkite_core".

.github/workflows/test.yaml

@@ -15,39 +15,26 @@ jobs:
       - name: Set up Python
         run: uv python install
 
-      # - name: Debug ty issue
-      #   run: |
-      #     uv pip install ty
-      #     uv pip list
-      #     uv run python -m ty check
-
       - name: Install dependencies
         run: |
           eval `ssh-agent -s`
           ssh-add - <<< '${{ secrets.LYNXSCRIBE_DEPLOY_KEY }}'
           uv venv
           . .venv/bin/activate
-          uv pip install \
-            -e lynxkite-core/[dev] \
-            -e lynxkite-app/[dev] \
-            -e lynxkite-graph-analytics/[dev] \
-            -e lynxkite-bio \
-            -e lynxkite-lynxscribe/ \
-            -e lynxkite-pillow-example/
+          echo PATH=$PATH >> $GITHUB_ENV
+          uv sync
 
       - name: Run pre-commits
         run: |
-          uv pip install pre-commit
-          uv run pre-commit run --all-files
+          pre-commit run --all-files
 
       - name: Run Python unittests
         run: |
-          uv run pytest --asyncio-mode=auto
+          pytest
 
       - name: Build the documentation
         run: |
-          uv pip install mkdocs-material mkdocstrings[python]
-          uv run mkdocs build
+          mkdocs build
 
       - uses: actions/setup-node@v4
         with:
@@ -61,7 +48,9 @@ jobs:
 
       - name: Run Playwright tests
         run: |
-          uv run bash -c 'cd lynxkite-app/web; npm run build; npm run test'
+          cd lynxkite-app/web
+          npm run build
+          npm run test
 
       - uses: actions/upload-artifact@v4
         name: Upload playwright report

docs/contributing.md

@@ -1,56 +0,0 @@
-# Contributing
-
-The LynxKite 2000:MM repository lives at
-[https://github.com/lynxkite/lynxkite-2000](https://github.com/lynxkite/lynxkite-2000). Bug reports, feature requests,
-and pull requests are welcome!
-
-## Project structure
-
-- `lynxkite-core`: Core types and utilities. Depend on this lightweight package if you are writing LynxKite plugins.
-- `lynxkite-app`: The LynxKite web application. Install some plugins then run this to use LynxKite.
-- `lynxkite-graph-analytics`: Graph analytics plugin. The classical LynxKite experience!
-- `lynxkite-pillow`: A simple example plugin.
-- `lynxkite-lynxscribe`: A plugin for building and running LynxScribe applications.
-- `lynxkite-bio`: Bioinformatics additions for LynxKite Graph Analytics.
-- `docs`: User-facing documentation. It's shared between all packages.
-
-## Development setup
-
-Install everything like this:
-
-```bash
-uv venv
-source .venv/bin/activate
-uvx pre-commit install
-uv sync
-```
-
-This also builds the frontend, hopefully very quickly. To run it:
-
-```bash
-cd examples
-lynxkite
-```
-
-If you also want to make changes to the frontend with hot reloading:
-
-```bash
-cd lynxkite-app/web
-npm run dev
-```
-
-## Executing tests
-
-```bash
-pytest                                # Runs all backend unit tests.
-pytest lynxkite-core                  # Runs tests for one package.
-cd lynxkite-app/web && npm run test   # Runs frontend tests.
-```
-
-## Documentation
-
-To work on the documentation:
-
-```bash
-mkdocs serve
-```

docs/guides/analytics.md

@@ -1,82 +0,0 @@
-# Graph analytics & data science
-
-Install LynxKite with the graph analytics package:
-
-```bash
-pip install lynxkite lynxkite-graph-analytics
-```
-
-Run LynxKite in your data directory:
-
-```bash
-cd lynxkite-data
-lynxkite
-```
-
-LynxKite by default runs on port 8000, so you can access it in your browser at
-[http://localhost:8000](http://localhost:8000).
-To run it on a different port, set the `PORT` environment variable (e.g., `PORT=8080 lynxkite`).
-
-## Using a CUDA GPU
-
-To make full use of your GPU, install the `lynxkite-graph-analytics` package with GPU support.
-
-```bash
-pip install lynxkite 'lynxkite-graph-analytics[gpu]'
-```
-
-And start it with the cuGraph backend for NetworkX:
-
-```bash
-NX_CUGRAPH_AUTOCONFIG=true lynxkite
-```
-
-## Directory browser
-
-When you open the LynxKite web interface, you arrive in the directory browser. You see
-the files and directories in your data directory — if you just created it, it will be empty.
-
-You can create workspaces, [code files](plugins.md), and folders in the directory browser.
-
-## Workspaces
-
-A LynxKite workspace is the place where you build a data science pipeline.
-Pipelines are built from boxes, which have inputs and outputs that can be connected to each other.
-
-To place a box, click anywhere in the workspace. This opens a search menu where you can
-find the box you want to add.
-
-## Importing your data
-
-To import CSV, Parquet, JSON, and Excel files, you can simply drag and drop them into the LynxKite workspace.
-This will upload the file to the server and add an "Import file" box to the workspace.
-
-You can also create "Import file" boxes manually and type the path to the file.
-You can either use an absolute path, or a relative path from the data directory.
-(Where you started LynxKite.)
-
-## Neural network design
-
-The graph analytics package includes two environments, _"LynxKite Graph Analytics"_, and _"PyTorch model"_.
-Use the dropdown in the top right corner to switch to the "PyTorch model" environment.
-This environment allows you to define neural network architectures visually.
-
-The important parts of a neural network definition are:
-
-- **Inputs**: These boxes stand for the inputs. You will connect them to actual data in the workspace that
-  uses this model.
-- **Layers**: The heart of the model. Use the _"Repeat"_ box looping back from the output of a layer to the
-  input of an earlier layer to repeat a set of layers.
-- **Outputs**: These boxes mark the place in the data flow that holds the predictions of the model.
-- **Loss**: Build the loss computation after the output box. This part is only used during training.
-- **Optimizer**: The result of the loss computation goes into the optimizer. Training is partially configured
-  in the optimizer box, partially in the training box in the workspace that uses the model.
-
-Once the model is defined, you can use it in other workspaces.
-
-- Load it with the _"Define model"_ box.
-- Train it with the _"Train model"_ box.
-- Generate predictions with the _"Model inference"_ box.
-
-See the [_Model definition_ and _Model use_ workspaces](https://github.com/lynxkite/lynxkite-2000/tree/main/examples)
-for a practical example.

docs/guides/plugins.md

@@ -1,283 +0,0 @@
-# Plugin development
-
-Plugins can provide additional operations for an existing LynxKite environment,
-and they can also provide new environments.
-
-## Creating a new plugin
-
-`.py` files inside the LynxKite data directory are automatically imported each time a
-workspace is executed. You can create a new plugin by creating a new `.py` file in the
-data directory. LynxKite even includes an integrated editor for this purpose.
-Click **New code file** in the directory where you want to create the file.
-
-Plugins in subdirectories of the data directory are imported when executing workspaces
-within those directories. This allows you to create plugins that are only available
-in specific workspaces.
-
-You can also create and distribute plugins as Python packages. In this case the
-module name must start with `lynxkite_` for it to be automatically imported on startup.
-
-### Plugin dependencies
-
-When creating a plugin as a "code file", you can create a `requirements.txt` file in the same
-directory. This file will be used to install the dependencies of the plugin.
-
-## Adding new operations
-
-Any piece of Python code can easily be wrapped into a LynxKite operation.
-Let's say we have some code that calculates the length of a string column in a Pandas DataFrame:
-
-```python
-df["length"] = df["my_column"].str.len()
-```
-
-We can turn it into a LynxKite operation using the
-[`@op`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.op) decorator:
-
-```python
-import pandas as pd
-from lynxkite.core.ops import op
-
-@op("LynxKite Graph Analytics", "Get column length")
-def get_length(df: pd.DataFrame, *, column_name: str):
-    """
-    Gets the length of a string column.
-
-    Args:
-        column_name: The name of the column to get the length of.
-    """
-    df = df.copy()
-    df["length"] = df[column_name].str.len()
-    return df
-```
-
-Let's review the changes we made.
-
-### The `@op` decorator
-
-The [`@op`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.op) decorator registers a
-function as a LynxKite operation. The first argument is the name of the environment,
-the last argument is the name of the operation. Between the two, you can list the hierarchy of
-categories the operation belongs to. For example:
-
-```python
-@op("LynxKite Graph Analytics", "Machine learning", "Preprocessing", "Split train/test set")
-```
-
-When defining multiple operations, you can use
-[`ops.op_registration`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.op_registration)
-for convenience:
-```python
-op = ops.op_registration("LynxKite Graph Analytics")
-
-@op("An operation")
-def my_op():
-    ...
-```
-
-### The function signature
-
-`*` in the list of function arguments marks the start of keyword-only arguments.
-The arguments before `*` will become _inputs_ of the operation. The arguments after `*` will
-be its _parameters_.
-
-```python
-#              /--- inputs ---\     /- parameters -\
-def get_length(df: pd.DataFrame, *, column_name: str):
-```
-
-LynxKite uses the type annotations of the function arguments to provide input validation,
-conversion, and the right UI on the frontend.
-
-The types supported for **inputs** are determined by the environment. For graph analytics,
-the possibilities are:
-
-- `pandas.DataFrame`
-- `networkx.Graph`
-- [`lynxkite_graph_analytics.Bundle`](../reference/lynxkite-graph-analytics/core.md#lynxkite_graph_analytics.core.Bundle)
-
-The inputs of an operation are automatically converted to the right type, when possible.
-
-To make an input optional, use an optional type, like `pd.DataFrame | None`.
-
-The position of the input and output connectors can be controlled using the
-[`@ops.input_position`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.input_position) and
-[`@ops.output_position`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.output_position)
-decorators. By default, inputs are on the left and outputs on the right.
-
-All **parameters** are stored in LynxKite workspaces as strings. If a type annotation is provided,
-LynxKite will convert the string to the right type and provide the right UI.
-
-- `str`, `int`, `float` are presented as a text box and converted to the given type.
-- `bool` is presented as a checkbox.
-- [`lynxkite.core.ops.LongStr`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.LongStr)
-  is presented as a text area.
-- Enums are presented as a dropdown list.
-- Pydantic models are presented as their JSON string representations. (Unless you add custom UI
-  for them.) They are converted to the model object when your function is called.
-
-### Slow operations
-
-If the function takes a significant amount of time to run, we must either:
-
-- Write an asynchronous function.
-- Pass `slow=True` to the `@op` decorator. LynxKite will run the function in a separate thread.
-
-`slow=True` also causes the results of the operation to be cached on disk. As long as
-its inputs don't change, the operation will not be run again. This is useful for both
-synchronous and synchronous operations.
-
-### Documentation
-
-The docstring of the function is used as the operation's description. You can use
-Google-style or Numpy-style docstrings.
-(See [Griffe's documentation](https://mkdocstrings.github.io/griffe/reference/docstrings/).)
-
-The docstring should be omitted for simple operations like the one above.
-
-### Outputting results
-
-The return value of the function is the output of the operation. It will be passed to the
-next operation in the pipeline.
-
-An operation can have multiple outputs. In this case, the return value must be a dictionary,
-and the list of outputs must be declared in the `@op` decorator.
-
-```python
-@op("LynxKite Graph Analytics", "Train/test split", outputs=["train", "test"])
-def test_split(df: pd.DataFrame, *, test_ratio=0.1):
-    test = df.sample(frac=test_ratio).reset_index()
-    train = df.drop(test.index).reset_index()
-    return {"train": train, "test": test}
-```
-
-### Displaying results
-
-The outputs of the operation can be used by other operations. But we can also generate results
-that are meant to be viewed by the user. The different options for this are controlled by the `view`
-argument of the `@op` decorator.
-
-The `view` argument can be one of the following:
-
-- `matplotlib`: Just plot something with Matplotlib and it will be displayed in the UI.
-
-    ```python
-    @op("LynxKite Graph Analytics", "Plot column histogram", view="matplotlib")
-    def plot(df: pd.DataFrame, *, column_name: str):
-        df[column_name].value_counts().sort_index().plot.bar()
-    ```
-
-- `visualization`: Draws a chart using [ECharts](https://echarts.apache.org/examples/en/index.html).
-  You need to return a dictionary with the chart configuration, which ECharts calls `option`.
-
-    ```python
-    @op("View loss", view="visualization")
-    def view_loss(bundle: core.Bundle):
-        loss = bundle.dfs["training"].training_loss.tolist()
-        v = {
-            "title": {"text": "Training loss"},
-            "xAxis": {"type": "category"},
-            "yAxis": {"type": "value"},
-            "series": [{"data": loss, "type": "line"}],
-        }
-        return v
-    ```
-
-- `image`: Return an image as a
-  [data URL](https://developer.mozilla.org/en-US/docs/Web/URI/Reference/Schemes/data)
-  and it will be displayed.
-- `molecule`: Return a molecule as a PDB or SDF string, or an `rdkit.Chem.Mol` object.
-  It will be displayed using [3Dmol.js](https://3Dmol.org/).
-- `table_view`: Return
-  [`Bundle.to_dict()`](../reference/lynxkite-graph-analytics/core.md#lynxkite_graph_analytics.core.Bundle.to_dict).
-
-## Adding new environments
-
-A new environment means a completely new set of operations, and (optionally) a new
-executor. There's nothing to be done for setting up a new environment. Just start
-registering operations into it.
-
-### No executor
-
-By default, the new environment will have no executor. This can be useful!
-
-LynxKite workspaces are stored as straightforward JSON files and updated on every modification.
-You can use LynxKite for configuring workflows and have a separate system
-read the JSON files.
-
-Since the code of the operations is not executed in this case, you can create functions that do nothing.
-Alternatively, you can use the
-[`register_passive_op`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.register_passive_op)
-and
-[`passive_op_registration`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.passive_op_registration)
-functions to easily whip up a set of operations:
-
-```python
-from lynxkite.core.ops import passive_op_registration, Parameter as P
-
-op = passive_op_registration("My Environment")
-op('Scrape documents', params=[P('url', '')])
-op('Conversation logs')
-op('Extract graph')
-op('Compute embeddings', params=[P.options('method', ['LLM', 'graph', 'random']), P('dimensions', 1234)])
-op('Vector DB', params=[P.options('backend', ['ANN', 'HNSW'])])
-op('Chat UI', outputs=[])
-op('Chat backend')
-```
-
-### Built-in executors
-
-LynxKite comes with two built-in executors. You can register these for your environment
-and you're good to go.
-
-```python
-from lynxkite.core.executors import simple
-simple.register("My Environment")
-```
-
-The [`simple` executor](../reference/lynxkite-core/executors/simple.md)
-runs each operation once, passing the output of the preceding operation
-as the input to the next one. No tricks. You can use any types as inputs and outputs.
-
-```python
-from lynxkite.core.executors import one_by_one
-one_by_one.register("My Environment")
-```
-
-The [`one_by_one` executor](../reference/lynxkite-core/executors/one_by_one.md)
-expects that the code for operations is the code for transforming
-a single element. If an operation returns an iterable, it will be split up
-into its elements, and the next operation is called for each element.
-
-Sometimes you need the full contents of an input. The `one_by_one` executor
-lets you choose between the two modes by the orientation of the input connector.
-If the input connector is horizontal (left or right), it takes single elements.
-If the input connector is vertical (top or bottom), it takes an iterable of all the incoming data.
-
-A unique advantage of this setup is that horizontal inputs can have loops across
-horizontal inputs. Just make sure that loops eventually discard all elements, so you don't
-end up with an infinite loop.
-
-### Custom executors
-
-A custom executor can be registered using
-[`@ops.register_executor`](../reference/lynxkite-core/ops.md#lynxkite.core.ops.register_executor).
-
-```python
-@ops.register_executor(ENV)
-async def execute(ws: workspace.Workspace):
-    catalog = ops.CATALOGS[ws.env]
-    ...
-```
-
-The executor must be an asynchronous function that takes a
-[`workspace.Workspace`](../reference/lynxkite-core/workspace.md#lynxkite.core.workspace.Workspace)
-as an argument. The return value is ignored and it's up to you how you process the workspace.
-
-To update the frontend as the executor processes the workspace, call
-[`WorkspaceNode.publish_started`](../reference/lynxkite-core/workspace.md#lynxkite.core.workspace.WorkspaceNode.publish_started)
-when starting to execute a node, and
-[`WorkspaceNode.publish_result`](../reference/lynxkite-core/workspace.md#lynxkite.core.workspace.WorkspaceNode.publish_result)
-to publish the results. Use
-[`WorkspaceNode.publish_error`](../reference/lynxkite-core/workspace.md#lynxkite.core.workspace.WorkspaceNode.publish_error)
-if the node failed.

docs/guides/quickstart.md

@@ -1,27 +0,0 @@
-# Quickstart
-
-Install the LynxKite application with `pip`:
-```bash
-pip install lynxkite
-```
-
-To be able to do anything useful, you also need to install one or more LynxKite environments.
-If you want to work with data science and graph analytics, install the `lynxkite-graph-analytics` package:
-```bash
-pip install lynxkite-graph-analytics
-```
-
-Create a folder for storing your LynxKite projects:
-```bash
-mkdir ~/lynxkite_projects
-```
-
-You're ready to run LynxKite!
-```bash
-cd ~/lynxkite_projects
-lynxkite
-```
-
-Open [http://localhost:8000/](http://localhost:8000/) in your browser.
-
-Find example workspaces in the [`examples` folder](https://github.com/lynxkite/lynxkite-2000/tree/main/examples).

docs/index.md

@@ -1,5 +0,0 @@
----
-title: Overview
----
-
---8<-- "README.md"

docs/license.md

@@ -1,11 +0,0 @@
-# License
-
-LynxKite 2000:MM is available under the GNU AGPLv3 license below.
-
-Additionally, [Lynx Analytics](https://www.lynxanalytics.com/) offers a commercial license of LynxKite 2000:MM
-that includes additional features and support. Get in touch if you are interested in life sciences tools
-and cluster deployment!
-
-```
---8<-- "LICENSE"
-```

docs/lynxkite-core.md

@@ -1,6 +0,0 @@
-# LynxKite Core
-
-LynxKite core is for writing LynxKite plugins.
-It contains core types and utilities that can be used by all LynxKite plugins.
-
-::: lynxkite.core.ops

docs/lynxkite-graph-analytics.md

@@ -1,6 +0,0 @@
-# LynxKite Graph Analytics
-
-This is the classical LynxKite experience!
-The graph analytics plugin is a collection of graph algorithms that can be run on a LynxKite graph.
-
-::: lynxkite_graph_analytics.lynxkite_ops

docs/reference/lynxkite-core/executors/one_by_one.md

@@ -1 +0,0 @@
-::: lynxkite.core.executors.one_by_one

docs/reference/lynxkite-core/executors/simple.md

@@ -1 +0,0 @@
-::: lynxkite.core.executors.simple

docs/reference/lynxkite-core/ops.md

@@ -1 +0,0 @@
-::: lynxkite.core.ops

docs/reference/lynxkite-core/workspace.md

@@ -1 +0,0 @@
-::: lynxkite.core.workspace

docs/reference/lynxkite-graph-analytics/core.md

@@ -1 +0,0 @@
-::: lynxkite_graph_analytics.core

docs/reference/lynxkite-graph-analytics/operations.md

@@ -1,3 +0,0 @@
-::: lynxkite_graph_analytics.lynxkite_ops
-::: lynxkite_graph_analytics.ml_ops
-::: lynxkite_graph_analytics.networkx_ops

docs/stylesheets/extra.css

@@ -1,8 +0,0 @@
-[data-md-color-scheme="lynxkite"] {
-  --md-primary-fg-color: #39bcf9;
-  --md-primary-fg-color--light: #9fdef9;
-  --md-primary-fg-color--dark: #096f9a;
-  --md-accent-fg-color: #ff8800;
-  --md-accent-fg-color--dark: #b86200;
-  --md-accent-fg-color--light: #ffbc70;
-}

examples/Cheminformatics/chembl_tools.py

@@ -1,4 +1,4 @@
-from lynxkite.core.ops import op
+from lynxkite_core.ops import op
 import pandas as pd
 from chembl_webresource_client.new_client import new_client
 from rdkit import Chem

examples/Cheminformatics/cheminfo_tools.py

@@ -1,6 +1,6 @@
 import os
 import pickle
-from lynxkite.core.ops import op
+from lynxkite_core.ops import op
 from matplotlib import pyplot as plt
 import pandas as pd
 from rdkit.Chem.Draw import rdMolDraw2D

examples/Cheminformatics/rcsb_api.py

@@ -4,7 +4,7 @@ import pypdb
 import biotite.database.rcsb as rcsb
 from MDAnalysis.analysis import rms
 from opencadd.structure.superposition.engines.mda import MDAnalysisAligner
-from lynxkite.core.ops import op
+from lynxkite_core.ops import op
 import os
 import numpy as np
 from Bio.PDB import PDBList, PDBParser, Superimposer

lynxkite-bio/src/lynxkite_bio/bionemo_ops.py

@@ -6,7 +6,7 @@ The operations are quite specific for this example notebook:
 https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb
 """
 
-from lynxkite.core import ops
+from lynxkite_core import ops
 import requests
 import tarfile
 import os

lynxkite-bio/src/lynxkite_bio/k8s.py

@@ -201,11 +201,11 @@ def needs(
     name: str,
     image: str,
     port: int,
-    args: list = None,
-    env: list = None,
-    forward_env: list = None,
-    health_probe: str = None,
-    storage_size: str = None,
+    args: list | None = None,
+    env: list | None = None,
+    forward_env: list | None = None,
+    health_probe: str | None = None,
+    storage_size: str | None = None,
     storage_path: str = "/data",
     namespace: str = "default",
 ):

lynxkite-bio/src/lynxkite_bio/llm.py

@@ -7,7 +7,7 @@ requirements.
 
 import openai
 import pandas as pd
-from lynxkite.core import ops
+from lynxkite_core import ops
 
 from . import k8s
 

lynxkite-bio/src/lynxkite_bio/nims.py

@@ -1,7 +1,7 @@
 """Wrappers for BioNeMo NIMs."""
 
 from lynxkite_graph_analytics import Bundle
-from lynxkite.core import ops
+from lynxkite_core import ops
 import httpx
 import io
 import pandas as pd

lynxkite-bio/src/lynxkite_bio/rdkit.py

@@ -1,7 +1,7 @@
 """An expansion for `lynxkite-graph-analytics` that provides algorithms for biological applications."""
 
 from lynxkite_graph_analytics import Bundle, RelationDefinition
-from lynxkite.core import ops
+from lynxkite_core import ops
 import numpy as np
 import pandas as pd
 import rdkit.Chem

lynxkite-lynxscribe/src/lynxkite_lynxscribe/llm_ops.py

@@ -7,13 +7,13 @@ as an "agentic logic flow". It might just get deleted.
 """
 
 import os
-from lynxkite.core import ops
+from lynxkite_core import ops
 import enum
 import jinja2
 import json
 import numpy as np
 import pandas as pd
-from lynxkite.core.executors import one_by_one
+from lynxkite_core.executors import one_by_one
 
 jinja = jinja2.Environment()
 chroma_client = None

lynxkite-lynxscribe/src/lynxkite_lynxscribe/lynxscribe_ops.py

@@ -30,9 +30,9 @@ from lynxscribe.components.chat.api import ChatAPI
 from lynxscribe.core.models.prompts import ChatCompletionPrompt, Message
 from lynxscribe.components.rag.loaders import FAQTemplateLoader
 
-from lynxkite.core import ops
+from lynxkite_core import ops
 import json
-from lynxkite.core.executors import one_by_one
+from lynxkite_core.executors import one_by_one
 
 DEFAULT_NEGATIVE_ANSWER = "I'm sorry, but the data I've been trained on does not contain any information related to your question."
 
@@ -860,11 +860,11 @@ def view(input):
     return v
 
 
-async def get_chat_api(ws: str):
-    from lynxkite.core import workspace
+async def get_chat_api(ws_path: str):
+    from lynxkite_core import workspace
 
     cwd = pathlib.Path()
-    path = cwd / (ws + ".lynxkite.json")
+    path = cwd / (ws_path + ".lynxkite.json")
     assert path.is_relative_to(cwd), f"Path '{path}' is invalid"
     assert path.exists(), f"Workspace {path} does not exist"
     ws = workspace.Workspace.load(path)
@@ -939,7 +939,7 @@ async def api_service_get(request):
 
 
 def get_lynxscribe_workspaces() -> list[str]:
-    from lynxkite.core import workspace
+    from lynxkite_core import workspace
 
     workspaces = []
     for p in pathlib.Path().glob("**/*"):

lynxkite-lynxscribe/tests/test_llm_ops.py

@@ -1,7 +1,7 @@
 import unittest
 from lynxkite_lynxscribe import llm_ops  # noqa: F401
-from lynxkite.core.executors import one_by_one
-from lynxkite.core import ops, workspace
+from lynxkite_core.executors import one_by_one
+from lynxkite_core import ops, workspace
 
 
 def make_node(id, op, type="basic", **params):

pyproject.toml

@@ -4,14 +4,14 @@ name = "lynxkite-enterprise-workspace"
 version = "0.1.0"
 requires-python = ">=3.12"
 dependencies = [
-    "lynxkite", "lynxkite-core", "lynxkite-graph-analytics[gpu]", "lynxkite-pillow-example",
+    "lynxkite-app", "lynxkite-core", "lynxkite-graph-analytics[gpu]", "lynxkite-pillow-example",
     "lynxkite-bio",
     "lynxkite-lynxscribe",
 ]
 classifiers = ["Private :: Do Not Upload"]
 
 [tool.uv.sources]
-lynxkite = { git = "https://github.com/lynxkite/lynxkite-2000", subdirectory = "lynxkite-app" }
+lynxkite-app = { git = "https://github.com/lynxkite/lynxkite-2000", subdirectory = "lynxkite-app" }
 lynxkite-core = { git = "https://github.com/lynxkite/lynxkite-2000", subdirectory = "lynxkite-core" }
 lynxkite-graph-analytics = { git = "https://github.com/lynxkite/lynxkite-2000", subdirectory = "lynxkite-graph-analytics" }
 lynxkite-pillow-example = { git = "https://github.com/lynxkite/lynxkite-2000", subdirectory = "lynxkite-pillow-example" }