How to Create Your Own Embeddings in Automata

Automata's documentation lists "Creating Your Own Embeddings" as a dedicated guide, and the embedding pipeline is what turns the Automata codebase and its docs into searchable vectors. To create your own, you work through three documented stages: configure the pyright-scip repository, update the code embeddings, then build and embed the docs. The page does not publish exact commands, so treat the steps below as the documented sequence to follow alongside the module docs rather than a copy-paste script.

What embeddings do in Automata

Automata describes itself as a self-programming AI system that uses large language models and a vector database to document, search, and write code. Embeddings are the bridge: code and documentation are converted into vectors so the system can retrieve relevant material during search and code generation. The docs list Embeddings first among the core features "in order of complexity," followed by code and documentation generation, indexing, execution, and the agent.

Two related pieces sit around the embedding step:

• Indexing — tutorials on creating and using SCIP indices for Automata Search.
• Symbol and symbol_embedding modules — listed in the module navigation, indicating embeddings are also maintained at the symbol level.

Prerequisites

• A local Automata environment set up per the setup guide ("Create Local Environment").
• Access to the pyright-scip repository, since the first documented step is configuring it.
• The embedding module documentation open, because the site notes module docs are auto-generated via the run-doc-embedding pipeline and still "a work in progress."

Step 1: Configure the pyright-scip repository

The "Creating Your Own Embeddings" page names this as the first task. pyright-scip is the indexing layer that produces SCIP data for the codebase; configuring it is what allows code to be analyzed before embedding. Follow the linked instructions on that page for the repository setup, and confirm the configuration works before moving on — later steps depend on it.

Step 2: Update the code embeddings

With indexing configured, the next documented task is updating the code embeddings. This regenerates vectors for the Automata interpreter codebase so search reflects current code. The Embeddings feature docs cover "how to generate code embeddings for Automata Interpreter codebase" and include associated examples and API documentation.

Expected result: an updated embedding set that the search and retrieval components can query. If results look stale after this step, the usual cause is that Step 1 was skipped or the index was not rebuilt — recheck the SCIP configuration first.

Step 3: Build and embed the docs

The third task is building and embedding the documentation. This mirrors the code path but for prose: docs are built, then embedded so they are retrievable alongside code. The site itself is generated this way — module documents are produced "via the run-doc-embedding pipeline," which is a useful reference point for what the output should look like.

Where the relevant docs live

Common sticking points

• Skipping the index step. Embeddings depend on the SCIP index produced from the configured pyright-scip repo; updating embeddings without it yields incomplete coverage.
• Expecting finished docs. The site explicitly warns module documentation is auto-generated and in progress, so some module pages may be thin. Use the feature-level guides and examples as the primary reference.
• Forgetting the docs half. Code embeddings alone leave documentation out of retrieval; run the build-and-embed docs step as well.

Once embeddings are in place, the natural next step is running an agent per the Agent Guide, which covers both trivial and non-trivial instruction execution.