A Rust agent framework with LangChain-compatible architecture and Rust-native async interfaces.

• LLM Providers — OpenAI, Anthropic, Gemini, Ollama, AWS Bedrock, Groq, Mistral AI, DeepSeek, and any OpenAI-compatible API (xAI, Together, Fireworks, OpenRouter…)
• LCEL Composition — Runnable trait with pipe operator (|), streaming, bind, parallel, branch, assign/pick, fallbacks
• Graph Orchestration — LangGraph-style StateGraph with conditional edges, persistent checkpointing (Redis + PostgreSQL), human-in-the-loop, streaming
• ReAct Agent — create_react_agent(model, tools) with automatic tool dispatch
• Tool System — Tool trait, ToolRegistry, SerialToolExecutor, ParallelToolExecutor, built-in tools (Tavily, DuckDuckGo, Wikipedia, SQL Toolkit)
• Memory — Buffer, Window, Summary, SummaryBuffer, TokenBuffer strategies with RunnableWithMessageHistory
• Prompt Templates — Chat templates, few-shot prompting, placeholder interpolation
• Output Parsers — String, JSON, Structured<T>, List, Boolean, Enum, XML — all composable as Runnable
• RAG Pipeline — Document loaders (Text, JSON, CSV, Markdown, Directory, Web, PDF), text splitters, embeddings (OpenAI, Ollama, Cohere, HuggingFace), vector stores (InMemory, Qdrant, pgvector, Pinecone, Chroma, MongoDB, Elasticsearch, Weaviate), 7 retriever types
• Caching — In-memory (TTL), semantic (embedding similarity), Redis, SQLite, CachedChatModel wrapper
• Evaluation — ExactMatch, JsonValidity, Regex, EmbeddingDistance, LLMJudge evaluators
• Structured Output — StructuredOutputChatModel<T> with JSON schema enforcement
• Observability — TracingCallback (structured spans), CompositeCallback, StdOutCallback
• MCP — MultiServerMcpClient with Stdio/SSE/HTTP transport adapters
• Macros — #[tool], #[chain], #[entrypoint], #[task], #[traceable] proc-macros
• Deep Agent — Filesystem-aware deep research agent harness (create_deep_agent)
• Middleware — AgentMiddleware trait: Retry, PII redaction, Prompt Caching, Summarization

[dependencies]
synaptic = { version = "0.2", features = ["agent"] }

use synaptic::core::{ChatModel, Message, ChatRequest, ToolChoice};
use synaptic::runnables::{Runnable, RunnableLambda};
use synaptic::graph::{create_react_agent, MessageState};

// LCEL pipe composition
let chain = step1.boxed() | step2.boxed() | step3.boxed();
let result = chain.invoke(input, &config).await?;

// ReAct agent
let graph = create_react_agent(model, tools)?;
let state = MessageState { messages: vec![Message::human("Hello")] };
let result = graph.invoke(state).await?;

45+ library crates in crates/, examples in examples/:

cargo run -p tool_calling_basic   # Tool registry and execution
cargo run -p memory_chat          # Session-based conversation memory
cargo run -p react_basic          # ReAct agent with tool calling
cargo run -p graph_visualization  # Graph state machine visualization
cargo run -p lcel_chain           # LCEL pipe composition and parallel
cargo run -p prompt_parser_chain  # Prompt template -> model -> parser
cargo run -p streaming            # Streaming chat and runnables
cargo run -p rag_pipeline         # RAG: load -> split -> embed -> retrieve
cargo run -p memory_strategy      # Memory strategies comparison
cargo run -p structured_output    # Structured output with JSON schema
cargo run -p callbacks_tracing    # Callbacks and tracing
cargo run -p evaluation           # Evaluator pipeline
cargo run -p caching              # LLM response caching
cargo run -p macros_showcase      # Proc-macro usage

All examples use ScriptedChatModel and FakeEmbeddings — no API keys required.

• Book: dnw3.github.io/synaptic — tutorials, how-to guides, concepts, integration reference
• API Reference: docs.rs/synaptic — full Rustdoc API documentation

• Core abstractions first, feature crates expanded incrementally
• LangChain concept compatibility with Rust-idiomatic APIs
• All traits are async via #[async_trait], runtime is tokio
• Type-erased composition via BoxRunnable with | pipe operator
• Arc<RwLock<_>> for shared registries, session-keyed memory isolation
• MSRV: 1.88

See CONTRIBUTING.md for guidelines, or the full guide.

MIT — see LICENSE for details.