Copied to clipboard
v1.9.1 · ReasoningLLM · AgentFederation · EvalCI

Build LLM Apps.

Build LLM Apps.

Build LLM Apps.

Async-native RAG, Agents, and Graph Workflows. 2 hard dependencies · 33 providers · No SaaS. No lock-in. No magic.

Get Started →View on GitHub
0
LLM Providers
0
Loaders
0
Vector Stores
0+
Tools
0
Dependencies
SCROLL

Live Pipeline

Watch it run.

Every request flows through composable Python nodes — no magic, no black boxes.

synapsekit · rag_pipeline.py
live
User Querynatural languageLoader53 sourcesVector Store22 backendsLLM33 providersAnswerstreaming
output

Each node is plain Python. Swap, extend, or debug any step — no black boxes.

Architecture

Six composable layers.
Use any. Use all.

01
Application Layer
Your code — scripts, FastAPI services, Jupyter notebooks
ScriptsFastAPINotebooksServices
02
Tools & CLI
CLI commands, PromptHub versioned prompts, 47+ extensible tools
CLIPromptHubPlugins47+ Tools
03
Core Orchestration
RAG Pipelines, ReAct Agents, Graph Workflows, AgentFederation
RAGPipelineAgentStateGraphFederation
04
Data & Memory
53 loaders, 11 vector stores, 20 retrieval strategies, 9 memory backends
53 Loaders11 StoresHybrid Search9 Backends
05
LLM Providers
33 providers, one BaseLLM interface — streaming and structured output
OpenAIAnthropicGemini+30 more
06
Async Core
numpy and rank-bm25 only — fully async, sync wrappers available
async/awaitStreamingnumpyrank-bm25
33LLM Providers
53Loaders
11Vector Stores
47+Tools
Architecture docs →

The Problem

Existing frameworks are bloated mazes.
You deserve better.

✗

50+ dependencies. 200 MB install. For what?

Most LLM frameworks pull in half of PyPI. Every import is a surprise. SynapseKit needs only numpy and rank-bm25.

✗

Async was bolted on. Not designed in.

Partial async support is unpredictable and fragile. SynapseKit is async/await native at every layer — no sync wrapper surprises.

✗

Cost tracking sold separately as a SaaS product.

Observability shouldn't require a subscription. SynapseKit tracks cost, tokens, and latency out of the box — locally.

The Solution

SynapseKit does the same in 10 lines.

Plain Python. No magic classes. No global state. Just functions you can read, debug, and extend.

agent_example.py
from synapsekit import agent, tool
 
@tool
def get_weather(city: str) -> str:
    return f"Sunny, 22°C in {city}"
 
# One line to create a full agent
my_agent = agent(
    model="gpt-4o-mini",
    api_key="sk-...",
    tools=[get_weather],
)
 
print(my_agent.run("What's the weather in Tokyo?"))
✓

Full async/await throughout — no sync/async mismatch

✓

Token-level streaming from every provider

✓

Swap model or provider in one line

✓

Cost tracking on every call, no SaaS needed

✓

No hidden chains. Every step is plain Python.

Read the quickstart →

Why SynapseKit

Every choice made deliberately.

Core architecture

Async-Native — built in, not bolted on.

Every API is async/await first. Sync wrappers for scripts. No event-loop surprises.

# async by default
result = await agent.run(prompt)
async for token in llm.stream(prompt):
print(token, end="")
SynapseKit~3× faster
Sync frameworks

Concurrent throughput, 100 parallel requests

Minimal footprint

2 Dependencies.

numpy + rank-bm25. Every other integration is optional. Install only what you need.

0HARD DEPENDENCIES
SynapseKit2
LangChain50+
LlamaIndex22
numpyrank-bm25

Output

Streaming-First.

Token-level streaming is the default across all 33 providers.

streaming output ▸

No black boxes

Transparent by Design.

No hidden chains. No global state. Every step is plain Python.

@tool
# decorate any function
agent()
# plain Python class
.run()
# call it — no magic
result
# just a dict

Ecosystem

33 Providers. One interface.

OpenAI, Anthropic, Gemini, Ollama, Bedrock and 28 more — same API, zero rewrites when you switch.

33
OpenAIAnthropicGeminiOllamaBedrockMistralGroqTogetherDeepSeekCohereFireworksReplicateHuggingFacexAIvLLMLM StudioWriterNovitaAzureVertex+13 more

Observability

Cost Tracking Built-In.

Per-call cost, tokens, and latency — tracked automatically. No SaaS needed.

Cost / query

$0.0012

↓ 8%

Avg latency

1.34s

↓ 12%

Tokens used

2.4M

this week

Total spend

$2.87

↑ $0.34

Comparison

How we stack up.

FeatureSynapseKitLangChainLlamaIndex
Hard dependencies250+20+
Install size~5 MB~200 MB+~100 MB+
Async-native✅ Default⚠️ Partial⚠️ Partial
Streaming✅ Default⚠️ Varies⚠️ Varies
Cost tracking✅ Built-in❌ SaaS add-on❌ No
Evaluation / EvalCI✅ CLI + GitHub Action❌ SaaS add-on✅ Built-in
Graph workflows✅ Built-in✅ Separate package❌ No
Agent federation✅ Built-in❌ No❌ No
Reasoning LLMs✅ Unified adapter⚠️ Manual⚠️ Manual
LicenseApache 2.0MITMIT

Capabilities

Everything you need. Nothing you don't.

53

Loaders

11

Vector Stores

3

Retrieval Modes

  • →

    53 loaders — PDF, Word, YouTube, S3, Notion, HubSpot, BigQuery, Salesforce, Airtable, Obsidian, and more

  • →

    11 vector stores — Chroma, Pinecone, Weaviate, pgvector, Redis, MongoDB Atlas, SQLiteVec, and more

  • →

    Hybrid search — semantic vector search + multi-hop Knowledge Graph retrieval in one call

  • →

    Built-in RAG evaluation — cost/benefit tracking, Slack alert sinks, per-call scoring

  • →

    Anthropic prompt caching via SmartContextManager — cuts costs on repeated context

EvalCI

Ship with confidence.
Gate quality on every PR.

EvalCI is a GitHub Action that runs your LLM evaluation suite on every pull request — before anything merges. Catch regressions automatically, not manually.

  • ✓Define eval cases with @eval_case decorator
  • ✓Compare every PR against a baseline model output
  • ✓Block merges when quality drops below threshold
  • ✓Track factual accuracy, faithfulness, cost per query
View EvalCI docs →
evalci · PR #247
$ synapsekit eval run --suite tests/evals/
→ Running 24 eval cases against gpt-4o-mini...
→ Comparing against baseline (main@f3a9c1b)...
 
✓ factual_accuracy 0.94 (+0.02)
✓ context_relevance 0.91 (±0.00)
✓ answer_faithfulness 0.88 (+0.03)
✓ cost_per_query $0.0012 (-8%)
 
24/24 passed 0 regressions GitHub PR: ✅ approved
▋

Ecosystem

Your entire stack, already supported.

33 LLM providers behind one unified API. Swap without rewriting a line.

OpenAIAnthropicGoogle GeminiOllamaAWS BedrockCohereMistralxAI GrokTogether AIDeepSeekGroqReplicateHuggingFaceWriterNovitaLM StudioGPT4AllOpenAIAnthropicGoogle GeminiOllamaAWS BedrockCohereMistralxAI GrokTogether AIDeepSeekGroqReplicateHuggingFaceWriterNovitaLM StudioGPT4All
vLLMAzure OpenAIVertex AIFireworksPerplexityAnyscaleDeepInfraOpenRouterCerebrasAI21Cloudflare AIAleph AlphaVoyage AIMosaicMLPredibaseDatabricksvLLMAzure OpenAIVertex AIFireworksPerplexityAnyscaleDeepInfraOpenRouterCerebrasAI21Cloudflare AIAleph AlphaVoyage AIMosaicMLPredibaseDatabricks
Data Loaders53

Load from anywhere. Get Documents everywhere.

Every loader returns the same Document object — whether it's a PDF, a YouTube video, a Salesforce export, or a BigQuery table. Your pipeline never needs to change.

docs = await PDFLoader('report.pdf').load()
PDFPDF
YouTubeYouTube
S3S3
NotionNotion
HubSpotHubSpot
BigQueryBigQuery
SalesforceSalesforce
MongoDBMongoDB
Vector Stores22

Start local. Go prod. Zero rewrites.

Chroma for your laptop, Pinecone for production, pgvector for your existing Postgres — all behind one interface. Change one line, not your entire codebase.

store = ChromaVectorStore() # swap to Pinecone later
ChromaChroma
PineconePinecone
WeaviateWeaviate
PostgresPostgres
RedisRedis
MongoDBMongoDB
QdrantQdrant
OpenSearchOpenSearch
Agent Tools47+

One decorator. Real-world actions.

Decorate any function with @tool and your agent can call it. Browser automation, SQL queries, GitHub PRs, Slack messages — all wired up and production-tested.

@tool async def query_db(sql: str) -> str: ...
GitHubGitHub
SlackSlack
StripeStripe
TwilioTwilio
JiraJira
NotionNotion
LinearLinear
AWS LambdaAWS Lambda
Memory Backends4

Agents that remember across sessions.

Episodic memory stores what happened. Semantic memory stores what matters. Both work across SQLite, Redis, and Postgres — start in-memory, scale to Redis in one line.

agent = Agent(memory=RedisMemory(url=REDIS_URL))
SQLiteSQLite
RedisRedis
PostgresPostgres
In-memoryIn-memory

Install

Start in seconds.

Install only what you need. Extras are truly optional.

terminal
# OpenAIpip install synapsekit[openai]
# Anthropicpip install synapsekit[anthropic]
# Ollama (local)pip install synapsekit[ollama]
# Observabilitypip install synapsekit[observe]
# Everythingpip install synapsekit[all]

Full options → installation docs

Documentation

Everything documented.
Nothing hidden.

All docs →
Up in 3 minutes

Quickstart

Build your first RAG pipeline or agent. pip install, configure a provider, ship.

Read the guide →
from synapsekit import RAGPipeline
pipeline = RAGPipeline(llm=llm, store=store)
result = await pipeline.query("How does X work?")
loader = PDFLoader("paper.pdf")
docs = await loader.load()
Retrieval-Augmented Generation

RAG Guide

Pipelines, loaders, hybrid retrieval, vector stores, evaluation.

Read →
agent = Agent(llm=llm, tools=[search, sql])
result = await agent.run(task)
ReAct · tools · memory

Agents

Function calling, tool use, episodic memory, and AgentFederation across services.

Read →
graph = Graph()
graph.add_edge(fetch, summarize)
DAG · parallel · conditional

Graph Workflows

Compose pipelines as graphs. Branch, merge, loop, and run subgraphs in parallel.

Read →
llm = LLM(model="gpt-4o") # OpenAI
llm = LLM(model="claude-3-5-sonnet") # Anthropic
33 providers · one interface

LLM Providers

ReasoningLLM, CostQualityRouter, streaming, structured output across all providers.

Read →
# Auto-generated from source
# Searchable, versioned, always current
Every class · every method

API Reference

Full reference for every public symbol, parameter, return type, and exception.

Read →