> ## Documentation Index
> Fetch the complete documentation index at: https://cognis.vasanth.xyz/llms.txt
> Use this file to discover all available pages before exploring further.
# Cognis
> Build LLM agents in Rust without the duct tape. Typed Runnables, an agent loop, a stateful graph engine, and production-grade RAG — all in one workspace.
# Build LLM agents in Rust without the duct tape.
Typed `Runnable` flows from your prompt to your parsed struct. Tool schemas are checked at compile time. Memory, retries, fallbacks, rate limits, prompt caching, evals — all in the box. **Six providers behind one client. Six vector stores behind one trait. One umbrella crate.**
```rust theme={null}
use std::sync::Arc;
use cognis::prelude::*;
use cognis::{AgentBuilder, Calculator, Client};
#[tokio::main]
async fn main() -> Result<()> {
let mut agent = AgentBuilder::new()
.with_llm(Client::from_env()?)
.with_tool(Arc::new(Calculator::new()))
.with_system_prompt("Use the calculator for arithmetic.")
.build()?;
let resp = agent.run(Message::human("What is 23 * 17 + 4?")).await?;
println!("{}", resp.content);
Ok(())
}
```
A real, working tool-calling agent in 11 lines. Swap `COGNIS_PROVIDER` between `openai`, `anthropic`, `google`, `ollama`, `azure`, or `openrouter` — same code.
## Real apps you can ship today
Planner → researcher (with web search) → writer. Sequential multi-agent in 80 lines.
Walk a Rust repo, embed code chunks, answer questions with file:line citations.
`axum` SSE endpoint streaming agent tokens, tool starts, and tool results to the browser.
Five more in the [Patterns gallery](/patterns/research-assistant) — multi-agent debate, long-context summarization, HITL approval, stateful chat with memory, and a fully local Ollama setup.
## What you can build
A model with tools, memory, and a loop that knows when to stop. Add middleware for retry, fallback, rate limits, PII redaction, and human approval.
Sequential pipelines, supervisor routers, parallel-vote ensembles, round-robin load balancing, hierarchical trees. Or wire your own `HandoffStrategy`.
Documents → splitters → embeddings → vector store → retriever → prompt. Six vector store backends. An indexing pipeline that only re-embeds what changed.
`Graph` with typed state and per-field reducers. Time-travel through checkpoints, pause for human approval, fan out in parallel — all type-checked at compile time.
LLM-aware tracing into Langfuse out of the box. Token counts, USD cost per run, prompt versioning, evaluation scores — one feature flag.
Run entirely against Ollama with no API keys. Swap to a hosted provider later — the agent code doesn't change.
## Why Rust
* **Compile-time guarantees.** Tool schemas, message types, and graph state transitions are checked before your code runs. No "unknown variant at runtime" surprises.
* **Pay only for what you use.** Every external integration is feature-gated. Your binary doesn't include OpenAI code if you only use Anthropic.
* **Async-native.** Built on `tokio` and `futures::Stream`. Streaming tokens, events, and graph state updates uses one consistent API.
* **One umbrella, full stack.** `cognis` re-exports the foundation, LLM, RAG, and graph layers. Most apps need a single `use cognis::prelude::*;`.
## What's not here yet
Honest about the gaps so you can decide whether to wait or contribute:
* **LangSmith and OpenTelemetry exporters** — Langfuse is the supported production backend; OTel + others are on the roadmap. The `TraceExporter` trait is one async method, so building your own is fast.
* **A hosted gateway / managed deployment** — bring your own infra. Production patterns are documented; managed runtime isn't shipping today.
* **A wider provider matrix** — six are battle-tested; others (Groq, Together, Bedrock direct, Cohere) are open issues looking for owners.
[See the full roadmap →](https://github.com/0xvasanth/cognis/issues)
## Where to next
From zero to a running agent in five minutes.
Workspace setup, feature flags, secrets handling.
Mental models for `Runnable`, graphs, and the agent loop.
Real applications you can copy: research assistants, code Q\&A, multi-agent debate, more.
Per-crate rustdoc-friendly summaries. Cross-linked to docs.rs.
Bugs, features, integrations, docs — every contribution lane.
Cognis is open source under MIT. Stars help other Rust devs find it.
