Swiftide
A Rust framework for streaming LLM applications: an agent harness, typed task graphs, and composable indexing/query RAG pipelines in one toolkit.
Evidence shows a local-default tool executor, an optional docker executor for isolation, human-in-the-loop approval via ApprovalRequired, and a customizable stop tool, giving basic constraints on privilege and external effects (2 each); but no fine-grained permission declaration, no documented secret/data redaction guidance, and no rollback mechanism, so no full marks.
Typed task graphs, stop conditions, structured failure payloads, and tracing/metrics support self-consistency and error reporting; pinned workspace dependency versions plus CI test and coverage badges support dependency availability; static review cannot verify runtime behavior, hence deductions.
README targets a clear audience (Rust developers building agents/RAG) with well-partitioned scenarios and examples, and states boundaries (pre-1.0, unstable APIs); however tool/stop semantics (trigger precision) are only described at a high level, and multi-provider environment fit is feature-gated description only.
Information architecture, install instructions, examples index, and MIT license (LICENSE matches Cargo.toml) are thorough — full marks; maintainers (core team, contributing guide, Discord) are identified; but no CHANGELOG file exists, version history relies on a crates.io badge, and known limitations get one sentence under Project Status.
Examples demonstrate composability, streaming output, and observability, supporting output usability; feature gating keeps dependency weight low, giving reasonable cost/benefit; actual utility requires execution, so only moderate scores are justified.
Most capability claims map to named example files and docs.rs links, giving moderate traceability; CI/coverage badges corroborate Cargo.toml and LICENSE; but static material cannot verify badge reality, and some claimed capabilities (resume, MCP toolboxes) are asserted without source detail in the provided files.
- Project is pre-1.0; APIs may change without notice — pin versions for production use.
- Agents execute tools/commands locally by default; configure isolation (e.g., the docker executor) and human approval before wiring an LLM.
- API keys are injected via environment variables (OPENAI_API_KEY); no documented redaction or log-leak protections — audit yourself.
- No CHANGELOG; review diffs before upgrading dependency versions.
- Publisher identity is unverified in the enterprise registry; establish trust independently.
What does this agent do, and when should you use it?
Swiftide is a Rust framework from the bosun-ai organization for building LLM applications, built on three pillars: an agent harness, typed task graphs, and streaming RAG indexing/query pipelines. The agent harness owns message history, calls an LLM, invokes tools, runs lifecycle hooks, and stops on configured conditions; task graphs orchestrate strongly typed nodes and transitions supporting parallel fan-out, pause, and resume; RAG pipelines stream data through loaders, transformers, embedders, caches, and storage backends. It integrates with many LLM providers including OpenAI, Anthropic, Gemini, and Ollama, plus storage like Qdrant, Redis, LanceDB, and PgVector, with MCP tool loading and Langfuse observability. The project is pre-1.0 with APIs that may change, and is distributed under the MIT license.
Swiftide delivers three capability lines. First, the agent harness: build agents via agents::Agent::builder(), register Rust functions as tools with the #[swiftide::tool] macro, and use AgentContext to abstract message history and a ToolExecutor (local by default, with a Docker executor option). It supports lifecycle hooks, human-in-the-loop approval via ApprovalRequired, structured stop/failure payloads, MCP toolboxes, and streaming responses. Second, task graphs: Task and TaskNode compose compile-time typed workflows where Transition decides output routing, with static fan-out/join, sequential or parallel execution, and pause/resume. Third, RAG pipelines: indexing::Pipeline chains FileLoader, ChunkCode (tree-sitter-based code chunking), MetadataQACode, Embed, and stores like Qdrant for indexing; query pipelines support query transformation, retrieval, hybrid search, reranking, and evaluation.
- Rust developers building retrieval-augmented Q&A over their codebases, loading .rs files with FileLoader, chunking with tree-sitter, embedding, and storing in Qdrant
- Teams building semi-autonomous agents that call local tools and include human approval steps, such as code review or ops assistants
- Platform teams orchestrating prompts, agents, and domain logic into strongly typed multi-node workflows that pause and resume for external callbacks
- AI product backends that need multiple LLM providers (OpenAI, Anthropic, Bedrock, Ollama) without vendor lock-in
- Data teams streaming large indexing workloads from Kafka, Fluvio, or Parquet sources with Langfuse tracing
What are this agent's strengths and limitations?
- One framework covers agent loops, typed task orchestration, and streaming RAG pipelines, avoiding gluing multiple libraries
- Multi-provider adapters (OpenAI, Anthropic, Gemini, Bedrock, Groq, Ollama, etc.) with feature gating keeping dependencies light
- Task graphs are strongly typed at build time — node input/output/error types are checked when composing, reducing runtime orchestration errors
- Native Rust implementation suited to performance-sensitive indexing and retrieval paths; the README explicitly flags attention to allocations on hot paths
- Open tool ecosystem: local Rust functions, custom Tool implementations, MCP servers, and a Docker executor all plug in
- Pre-1.0 status: the README explicitly warns APIs can change, so upgrades carry migration risk
- Requires familiarity with async Rust (Tokio, Arc, trait objects) — a high bar for non-Rust teams
- Storage, data-source, and observability features depend on external systems (Qdrant, Redis, Kafka, Langfuse), increasing deployment complexity
- Documentation leans on API docs and examples; the README admits examples are the most reliable source of exact signatures, so formal docs may lag
How do you install or deploy this agent?
Install via Cargo with needed features:
sh
cargo add swiftide --features swiftide-agents,openai
cargo add anyhow
cargo add tokio --features macros,rt-multi-threadFor OpenAI, set the API key:
sh
export OPENAI_API_KEY=...
Integrations are feature-gated so builds stay light.
How do you use this agent?
Minimal agent: build an LLM client with swiftide::integrations::openai::OpenAI::builder().default_prompt_model("gpt-4o-mini").build()?; define async tool functions with #[swiftide::tool]; construct the agent with agents::Agent::builder().llm(&openai).tools([...]).on_new_message(...).limit(8).build()?, then call .query("...").await?. For RAG indexing, use indexing::Pipeline::from_loader(FileLoader::new(".")) chained with then_chunk, then, then_in_batch(Embed::new(...)), then_store_with(qdrant), and .run().await?. The examples directory includes hello_agents, tasks, tasks_fanout, hybrid_search, langfuse, and more runnable examples.