Enzyme SDK Preview Private beta

Your users accumulate taste — annotated recipes, saved references, logged experiments, collected research. You could build a RAG pipeline that your agent could query, but it wouldn’t know what to ask. Enzyme gives the user’s words to the agent, so it can find what matters: the patterns, preferences, and taste built through hundreds of small choices they never think to articulate.

A cooking app

Let’s say one user has saved and commented on 407 recipes. The user asks:

RAG might search “vegetarian dinner” against the recipe collection and return the closest matches. Enzyme does something different — the query matches against a pre-computed question that already knows what connects this user’s entries:

With Enzyme, your agent knows that taste isn’t built on a search problem, but an associative one. It matched against a pattern Enzyme found across a year of annotations — miso for butter, tahini for cream, fermented for dairy — none tagged the same way, none sharing a keyword. The indirection surfaces entries that no amount of better embedding search would reach.

The user gets a sandbox, not search results — not generic vegetarian recipes, but dishes that play to their specific palate. And the dessert suggestion isn’t a random upsell; it’s a miso-brown-butter cookie the user will make, love, and annotate, which sharpens the catalysts for next time.

How catalysts work

“vegetarian dinner for friends” lands far away in embedding space from the banana bread comment from last September, so ranking comments to the query by pure cosine similarity would have missed the connection. Enzyme pre-computes an indirection layer: it reads the accumulated entries, finds recurring patterns, and generates catalysts — thematic questions — for each one. At query time, the agent matches against those questions, not the documents directly.

User's query:    "vegetarian dinner for friends"

Catalyst match:  "Fermented for dairy, consistently — umami depth
                  or past richness-through-fat?"

Your users’ queries of the moment deserve the recognition of their taste across time. The catalyst is specific to this person — formed from annotations that don’t share a keyword or tag:

Personalization is built at index time and catalysts evolves off of the query request path. With these catalysts, the agent wastes no time finding the right user content to answer from.

Integration

The SDK starts from your app’s own model. Define the activity your product already has — saved recipes, comments, agent observations, edits, accepted suggestions — then map it once into an Enzyme connector.

from enzyme_sdk import Activity, CatalystProfile, EnzymeConnector, enzyme

connector = EnzymeConnector(
    app_id="cooking-app",
    display_name="Cooking App",
    content_label="cooking notes",
    collections=[UserRecipeComment, AgentObservedPreference],
    catalyst_profiles={
        UserRecipeComment: CatalystProfile.PREFERENCE_EVIDENCE,
        AgentObservedPreference: CatalystProfile.PREFERENCE_EVIDENCE,
    },
)

@enzyme.hydrate(connector)
def hydrate_user(user_id: str):
    return db.load_recipe_comments_and_observations(user_id)

@enzyme.transform(connector)
def to_activity(item) -> Activity:
    return Activity(
        title=item.title,
        content=item.notes,
        created_at=item.created_at,
        source_id=item.id,
        collections=[type(item)],
        metadata={"labels": item.tags},
    )

That connector becomes the integration surface. Serve it as MCP for agent clients, query hosted search from your product, or point it at a self-hosted search service when data residency or deployment constraints require it:

# Expose the same connector as a user-scoped MCP server.
connector.serve(port=9460, init_users=["user-1", "user-2"])

# For local testing with Claude or another MCP client:
# python examples/run_mcp_server.py --ngrok

# Query Enzyme's hosted search from your product.
scope = connector.hosted("user-123")
response = scope.catalyze(
    "quick vegetarian dinner ideas with umami depth",
    limit=8,
)

for result in response.results:
    print(result.source_id, result.title)

# Run search in your own environment when needed.
scope = connector.self_hosted(
    "user-123",
    base_url="http://localhost:8766",
)

response = scope.catalyze(
    "what has this user been returning to?"
)

Enzyme saves you tokens in understanding any domain where choices accumulate — saved bookmarks, logged experiments, collected references. The sharper the reasoning in your data, the sharper the catalysts. We’ll help you figure out what your activity model looks like in Enzyme during onboarding.

Questions