synapsekit 2.0.1

Build production LLM apps with 2 dependencies. Async-native RAG, Agents, and Graph workflows — no magic, no SaaS, no bloat.

"LangChain for people who hate LangChain."

SynapseKit is the minimal, async-first Python framework for LLM applications. 35 providers · 50 tools · 66 loaders · 22 vector stores. Every abstraction is plain Python you can read, debug, and extend. No hidden chains. No global state. No lock-in.

🎬 See it live

▶ Play the demo  ·  watch every LLM call, tool, retrieval, DB write, knowledge-graph update, cost, and human approval stream live.

SynapseKit Live — a zero-dependency, real-time dashboard built into the framework.

Run the live dashboard locally — three ways, no extra dependencies (it uses only the Python standard library):

# 1. Zero-touch: set one env var and run your program as usual.
#    The dashboard auto-starts on the first agent/RAG/graph call and opens your browser.
SYNAPSEKIT_LIVE=1 python your_agent.py

# 2. From the CLI — start it, then run your code in another shell.
synapsekit ui --live            # serves http://127.0.0.1:7900

# 3. From code.
python -c "from synapsekit.live import enable; enable()"   # opens the tab; keep the process alive

Or try a ready-made demo that exercises everything (loader → embeddings → retrieval → tools/MCP → memory/DB → knowledge graph → LLM, with logs, a flame graph, and a human approval):

python examples/live_showcase.py          # set ANTHROPIC_API_KEY first for real Claude calls

It opens http://127.0.0.1:7900 and stays live while your process runs — bound to localhost, token-gated, and a no-op when the env var isn't set (zero overhead in production).

10-Line Agent Example

from synapsekit import agent, tool

@tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    return f"Sunny, 22°C in {city}"

my_agent = agent(
    model="gpt-4o-mini",
    api_key="sk-...",
    tools=[get_weather],
)

print(my_agent.run("What's the weather in Tokyo?"))

SynapseKit vs LangChain vs LlamaIndex

LangChain has more raw integrations and more tutorials. That's not what SynapseKit is optimizing for. SynapseKit is optimizing for the engineer who needs to ship, debug, and maintain an LLM feature in production — where readable code, predictable async behavior, and no surprise SaaS bills actually matter.

New in 2.0.0

Version 2.0 is about trust and autonomy in production — provable behavior, self-managing memory, richer retrieval, and local-first operation. It also ships a repo-wide hardening pass: 42 audited security, reliability, and performance fixes, each with a regression test.

• Verifiable Agents — cryptographically signed, hash-chained audit trails (RFC 6962 Merkle batch signing, Ed25519 + pluggable KMS/BYOK) with a standalone verifier that returns MATCH / DRIFT / UNVERIFIABLE. Prove exactly what your agent did.
• Living Memory — agents propose signed, diffable patches to their memory files instead of silently overwriting them; review, apply, or revert.
• Property Graph RAG — vector search fused with graph traversal (NetworkX + Neo4j), plus a graph-backed AgentMemory.
• WorldModelRAG — temporal knowledge-graph RAG with causal links and validity windows.
• Personal Knowledge Mesh — local-first, incremental indexing across every project on your machine, with a synapsekit mesh CLI and MCP tools.
• AgentSwarm — market-based agent routing (sealed-bid, Vickrey, English, coalition auctions) with reputation learning.
• SelfImprovingAgent — eval-gated agent config evolution with signed patches and canary rollout. Run the offline self_evolving_agent.ipynb notebook to watch held-out accuracy climb 40% → 100% while every bad patch is blocked by the gate.
• NeuroSymbolicAgent — LLM-extracted constraints verified by Z3 / SymPy / MiniZinc / Prolog backends.
• EdgeRuntime — local-first inference with policy-gated cloud fallback and PII redaction before any data leaves the device.

2.0.1 is a security and close-out patch: an OSV audit of the full dependency graph bumped 8 packages off known-vulnerable versions (cryptography, pillow, aiohttp, gitpython, mcp, pyasn1, httplib2, setuptools) so a fresh install resolves to 0 known vulnerabilities, and the last open acceptance criteria on Self-Evolving Agents and the Neuro-Symbolic layer are closed. No public API changed — upgrade with pip install --upgrade synapsekit.

Upgrading from 1.x? See the Migrating to 2.0 guide — there are a few breaking changes (the top-level AgentMemory export, audit verify() trust anchoring, bundle schema 1.2, and default LLM retries).

pip install --upgrade synapsekit

Computer Use

ComputerUseAgent lets a model work through a screen provider instead of an API. It observes the current screen, asks a provider for one normalized action, applies a SafetyPolicy, executes the action, and records a replayable session log.

from synapsekit import (
    AnthropicComputerUseProvider,
    BrowserScreenProvider,
    ComputerUseAgent,
    SafetyPolicy,
)

agent = ComputerUseAgent(
    provider=AnthropicComputerUseProvider(client=anthropic_client, model="claude-3-5-sonnet"),
    screen=BrowserScreenProvider(headless=True, allowed_domains=["example.com"]),
    safety=SafetyPolicy(
        confirm_before=["delete", "send", "purchase", "navigate_to_new_domain"],
        forbidden_apps=["keychain", "1password"],
        record_session=True,
    ),
    recorder="runs/computer-use-session.jsonl",
)

result = await agent.run("Open the legacy form, enter the invoice total, and stop.")

Install optional runtime dependencies only when you need real screen control:

pip install "synapsekit[computer-use]"

Read Computer Use Safety before running this against real desktops, browsers, credentials, or production systems.

Who is it for?

SynapseKit is for Python developers who want to ship LLM features without fighting their framework.

• Burned LangChain users — hit a wall with debugging, dependency hell, or version churn and want full control back
• Async backend engineers — building FastAPI services where LangChain's sync-first model feels bolted on
• Cost-conscious teams — startups and teams who don't want a LangSmith subscription for basic observability
• ML engineers — building RAG or agent pipelines who need full control over retrieval, prompting, and tool use

What it covers

from synapsekit import AgentSwarm, BidStrategy, MarketPolicy

swarm = AgentSwarm(
    agents=[researcher, coder, critic, planner, summarizer],
    market=MarketPolicy(
        bid_strategy=BidStrategy.cost_quality_pareto(),
        auction_type="sealed_bid",
        budget_per_task=10_000,
        seed=42,
    ),
)

result = await swarm.execute("Write a market analysis on quantum compute startups")
print(result.winners)
print(swarm.trace_to_mermaid())

ReasoningAgent (automatic routing)

import asyncio

from synapsekit import ReasoningAgent, ReasoningAgentConfig

from synapsekit.agents.tools import CalculatorTool

from synapsekit.llm import LLMConfig, OpenAILLM, ReasoningLLM

fast = OpenAILLM(
    LLMConfig(model="gpt-4o-mini", api_key="sk-...", provider="openai")
)

reasoning = ReasoningLLM(model="o3", api_key="sk-...")


agent = ReasoningAgent(
    ReasoningAgentConfig(
        fast_llm=fast,
        reasoning_llm=reasoning,
        tools=[CalculatorTool()],
        agent_type="function_calling",
    )
)


async def main():

    answer = await agent.run("Solve: find the eigenvalues of [[2,1],[1,2]]")
    print(answer)


asyncio.run(main())

EvalHub quick usage

synapsekit bench --list
synapsekit bench --suite community/customer-support --model gpt-4o-mini
synapsekit bench --publish my_evals/ --name myorg/rag-finance

Docs: docs/evalhub.md

Neuro-Symbolic Verification

SynapseKit can pair a reasoning model with a symbolic solver so the model proposes formal constraints and the solver verifies the answer.

from synapsekit import NeuroSymbolicAgent, ReasoningLLM, Z3Backend

agent = NeuroSymbolicAgent(
    llm=ReasoningLLM("claude-3-7-sonnet-latest", api_key="..."),
    verifier=Z3Backend(),
    on_unverified="retry",
    max_proposals=3,
)

result = await agent.solve("Find an integer x where x > 3 and x < 5.")

print(result.answer)
print(result.verified)
print(result.proof.model)

Install solver integrations with pip install synapsekit[symbolic]. Prolog verification uses the swipl executable when PrologBackend is selected.

Integrations

Icons use Google Favicons for reliability across light and dark themes.

🧠 LLM Providers — 35 supported

Every provider implements the same BaseLLM interface. Auto-detected from model name — gpt-4o → OpenAI, claude-* → Anthropic, gemini-* → Google. Swap without rewriting.

OpenAI	Anthropic	Gemini	Azure OpenAI	AWS Bedrock	Vertex AI	Mistral	Cohere
Groq	Hugging Face	Cloudflare	Databricks	Perplexity	Replicate	xAI (Grok)	Baidu ERNIE
DeepSeek	Ollama	Together AI	OpenRouter	Fireworks AI	Cerebras	SambaNova	NovitaAI
Writer	AI21 Labs	Aleph Alpha	Minimax	Moonshot	Zhipu	LM Studio	llama.cpp
vLLM	GPT4All	MLX

🗄 Vector Stores — 22 backends

All implement VectorStore with add(), search(), search_mmr(), save(), and load(). Built-in InMemoryVectorStore needs zero extra deps. Everything else is pip install synapsekit[name].

ChromaDB	FAISS	Qdrant	Pinecone	Weaviate	Milvus	LanceDB	PGVector
SQLiteVec	MongoDB Atlas	Redis	Elasticsearch	OpenSearch	Supabase	Cassandra	DuckDB
ClickHouse	Marqo	Typesense	Vespa	Zilliz

📂 Data Loaders — 66 sources

All return list[Document] with .text and .metadata. Every loader has a sync .load() and async .aload(). Load from disk, cloud, databases, or APIs — same interface everywhere.

File Formats

PDF	Word (DOCX)	Excel (XLSX)	PowerPoint	HTML / XML	Markdown	LaTeX	YAML / JSON
Parquet	Audio (Whisper)	Video	RSS / Sitemap	Git Repo

Cloud Storage

AWS S3

Google Drive

Azure Blob

OneDrive

Dropbox

Google Cloud

Databases

PostgreSQL	MySQL	MongoDB	DynamoDB	Elasticsearch	Redis	BigQuery	Snowflake
SQLite	Supabase

APIs & Productivity

GitHub	Jira	Confluence	Notion	Slack	Discord	HubSpot	Salesforce
Airtable	YouTube	Reddit	Wikipedia	Obsidian	Google Sheets	Firebase	Twilio
arXiv	PubMed	Email (IMAP)

🔧 Agent Tools — 50 built-in

All implement BaseTool with a single async run(). Pass any list of tools to ReActAgent or FunctionCallingAgent. Write your own in 5 lines.

DuckDuckGo	Google Search	Tavily	Wolfram Alpha	Wikipedia	YouTube	arXiv	PubMed
Slack	Discord	GitHub API	Jira	Notion	Linear	Stripe	Twilio
Google Calendar	AWS Lambda	Browser (Playwright)	SQL Query	Python REPL	Shell

🧠 Memory & Cache Backends

SQLite

Redis

PostgreSQL

DynamoDB

Memcached

📡 Observability

OpenTelemetry

Prometheus

Grafana

PrometheusMetrics records synapsekit_cost_usd_total, synapsekit_tokens_total, and synapsekit_latency_seconds per model/provider. Hooks into the existing observe span pipeline — no code changes needed. Helm chart for a Prometheus + Grafana stack ships in assets/helm/synapsekit-observability/. pip install synapsekit[observe].

Multi-Hop Knowledge Graph RAG

SynapseKit provides advanced retrieval modules, including vector search and multi-hop Knowledge Graph (KG) retrieval.

When to use which?

• Vector Search (Semantic): Best for broad conceptual queries, finding similar passages, or answering questions whose answers are contained within a single chunk of text.
• Knowledge Graph (KG): Best for specific, multi-hop reasoning questions where the relationship spans across multiple documents (e.g., finding out who owns the parent company of a subsidiary).
• Hybrid (Vector + KG): Combining both strategies guarantees that you capture deep semantic context while also exploring explicitly extracted entity relationships. Initialize the RAG facade with graph_store=NetworkXStore() or Neo4jStore(...) to enable this out-of-the-box.

Production RAG ROI

from synapsekit import RAG, RAGEvaluator, SlackWebhookAlertSink
from synapsekit.cli.ui_server import create_app

rag = RAG(
    model="gpt-4o-mini",
    api_key="sk-...",
    evaluator=RAGEvaluator(
        judge_llm=judge_llm,  # a cheaper judge model
        sample_rate=0.1,
        alert_sinks=[SlackWebhookAlertSink(webhook_url=SLACK_WEBHOOK_URL)],
    ),
)

app = create_app(tracer=rag.tracer, rag_evaluator=rag.evaluator)
answer = await rag.ask("What changed in the release notes?")
await rag.wait_for_evaluations()

metrics = rag.tracer.summary()
print(metrics["avg_rag_benefit_to_cost"])
print(metrics["total_rag_alerts"])

Install

pip

pip install synapsekit[openai]       # OpenAI
pip install synapsekit[anthropic]    # Anthropic + prompt caching
pip install synapsekit[ollama]       # Ollama (local)
pip install synapsekit[performance]  # orjson + uvloop + xxhash (faster)
pip install synapsekit[observe]      # OpenTelemetry + Prometheus metrics
pip install synapsekit[training]     # Continuous fine-tuning pipeline
pip install synapsekit[bench]        # pytest-benchmark + ASV harness
pip install synapsekit[redis]        # Redis agent registry + memory backends
pip install synapsekit[all]          # Everything

uv

uv add synapsekit[openai]
uv add synapsekit[all]

Poetry

poetry add synapsekit[openai]
poetry add "synapsekit[all]"

Docker — official images on GitHub Container Registry, no Python setup required:

# Core library + CLI
docker pull ghcr.io/synapsekit/synapsekit:latest
docker run --rm ghcr.io/synapsekit/synapsekit --version

# Batteries-included (all extras baked in)
docker pull ghcr.io/synapsekit/synapsekit:all

# Serve a SynapseKit app as an HTTP API (bind 0.0.0.0 inside the container)
docker run --rm -p 8000:8000 -v "$PWD:/app" -w /app \
  ghcr.io/synapsekit/synapsekit serve my_module:rag --host 0.0.0.0

Tags: :latest / :<version> (core) and :all / :<version>-all (all extras). A matching image is published automatically on every release.

Full installation options → docs

Observability guide → docs/observability.md

Documentation

Everything you need to get started and go deep is in the docs.

Development

git clone https://github.com/SynapseKit/SynapseKit
cd SynapseKit
uv sync --group dev
uv run pytest tests/ -q

Contributing

Contributions are welcome — bug reports, documentation fixes, new providers, new features.

Read CONTRIBUTING.md to get started. Look for issues tagged good first issue if you're new.

Community

• 💬 Discord — chat, help, show and tell
• 💬 Discussions — ask questions, share ideas
• 🧭 Discord roles draft — proposed roles and permissions for issue #389
• 🧭 Discord release webhook draft — automate release announcements for issue #390
• 🐛 Bug reports
• 💡 Feature requests
• 🔒 Security policy

Contributors

Nautiverse 💻 📖 🚧

Gordienko Andrey 💻

Deepak singh 💻

by22Jy 💻

Arjun Kundapur 💻

Harshit Gupta 📖

Dhruv Garg 💻

Adam Silva 💻

qorex 💻

Abhay Krishna 💻

AYUSH BHATT 💻

HARSH 📖

mikemolinet 💻 🐛

Alessandro Mecca 💻 🐛

License

Apache 2.0