chronos

module

v0.10.0 Latest Latest Go to latest Published: Jul 31, 2026 License: MIT

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/spawn08/chronos

Links

Open Source Insights

README ¶

Chronos

A Go framework for building durable, scalable AI agents.
Define agents. Connect any LLM. Let them collaborate.

Install · Quickstart · Docs · Examples · Roadmap

Features

Layer	What it does
SDK	Agent builder, teams (sequential/parallel/router/coordinator), memory, knowledge (RAG), inter-agent protocol bus
Engine	StateGraph runtime with checkpointing and interrupt nodes, 14+ LLM providers, tool registry, guardrails, hooks, SSE streaming
ChronosOS	HTTP control plane — auth, RBAC, tracing, audit logs, approval API
Storage	SQLite, PostgreSQL, Redis, MongoDB, DynamoDB, Qdrant, Pinecone, Weaviate, Milvus
CLI	Interactive REPL, headless batch mode, session/memory management, YAML-first config

Install

CLI Binary (Linux / macOS / Windows)

curl -fsSL https://raw.githubusercontent.com/spawn08/chronos/main/install.sh | bash

Pre-built binaries for linux/amd64, linux/arm64, darwin/amd64 (Intel), darwin/arm64 (Apple Silicon), windows/amd64, and windows/arm64 are published to GitHub Releases.

Go Module

go get github.com/spawn08/chronos

Build from Source

git clone https://github.com/spawn08/chronos.git && cd chronos
make build    # outputs bin/chronos

Quickstart

YAML config — create .chronos/agents.yaml:

defaults:
  model:
    provider: openai
    api_key: ${OPENAI_API_KEY}
  storage:
    backend: sqlite
    dsn: chronos.db

agents:
  - id: dev
    name: Dev Agent
    model:
      model: gpt-4o
    system_prompt: You are a senior software engineer.

chronos repl                            # interactive chat
chronos run "explain Go interfaces"     # headless one-shot

Go builder API:

a, _ := agent.New("chat", "Chat Agent").
    WithModel(model.NewOpenAI(os.Getenv("OPENAI_API_KEY"))).
    WithSystemPrompt("You are a helpful assistant.").
    Build()

resp, _ := a.Chat(ctx, "What is the capital of France?")
fmt.Println(resp.Content)

Graph-based agent:

g := graph.New("pipeline").
    AddNode("greet", func(_ context.Context, s graph.State) (graph.State, error) {
        s["message"] = fmt.Sprintf("Hello, %s!", s["user"])
        return s, nil
    }).
    SetEntryPoint("greet").
    SetFinishPoint("greet")

a, _ := agent.New("hello", "Hello Agent").WithGraph(g).Build()
result, _ := a.Run(ctx, map[string]any{"user": "World"})

Examples

All examples with No API keys run with mock providers — no external calls.

Example	Description	Needs Keys?
quickstart	Minimal agent with SQLite and 3-node graph	No
tools_and_guardrails	Tool permissions + input/output guardrails	No
hooks_observability	Metrics, cost tracking, caching, retry, rate limiting	No
graph_patterns	Conditional edges, interrupt nodes, checkpoints	No
memory_and_sessions	Short/long-term memory, multi-turn sessions	No
streaming_sse	Pub/sub broker, graph events, SSE HTTP server	No
chat_with_tools	Agent chat with calculator and lookup tools	No
fallback_provider	Provider chain with automatic failover	No
sandbox_execution	Process sandbox with timeouts and I/O capture	No
wasm_sandbox	Run an untrusted WASI module in the wazero-backed sandbox	No
k8s_sandbox	Run a command as a hardened one-shot Kubernetes Job	No*
durable_queue	Durable work queue: leased workers, durable sleep, park/signal HITL, orphan recovery	No
durable_hitl	Human-in-the-loop approval with checkpoint + resume	No
multi_round_tools	Multi-round sequential tool calls retaining full context	No
multitenancy	Storage-level tenant isolation via `storage.WithTenant`	No
multitenant_memory	Per-user long-term memory isolation on one agent	No
cli_agent	Build, inspect, and run an agent from YAML via the CLI	No
cli_ops	Operate Chronos from the CLI: serve, monitor, db, sessions, pipe, deploy	No
multi_agent	All 4 team strategies, bus delegation	Optional
multi_provider	OpenAI, Anthropic, Gemini, Mistral, Ollama, Azure OpenAI, Vertex AI, Bedrock	Yes
azure	Azure OpenAI (chat + streaming) with deployment/API-version config	Yes
vertex	Google Cloud Vertex AI via OpenAI-compatible endpoint + gcloud token	Yes
enterprise_sso	ChronosOS behind OIDC/JWKS SSO (Okta, Azure AD, Google, Auth0)	Yes
data_residency	Per-tenant storage routing (EU vs US) with a single logical agent	No
mcp_agent	Agent using MCP tools over stdio transport	Yes
mcp_sse	MCP client over the HTTP+SSE transport (self-contained demo server)	No

Run any example: go run ./examples/<name>/

* k8s_sandbox needs a reachable Kubernetes cluster; with none configured it prints setup guidance and exits cleanly.

Every example that needs a real LLM (coding_agent, graph_with_llm, mcp_agent, multi_agent, team_deploy, multi_provider) resolves its provider through examples/internal/providers.Pick(), so any of these env combos works interchangeably:

Provider	Environment
OpenAI	`OPENAI_API_KEY`
Anthropic	`ANTHROPIC_API_KEY`
Google Gemini (AI Studio)	`GEMINI_API_KEY`
Azure OpenAI	`AZURE_OPENAI_API_KEY` + `AZURE_OPENAI_ENDPOINT` + `AZURE_OPENAI_DEPLOYMENT` (+ optional `AZURE_OPENAI_API_VERSION`)
Google Cloud Vertex AI	`GOOGLE_CLOUD_PROJECT` + `GOOGLE_ACCESS_TOKEN` (+ optional `GOOGLE_CLOUD_LOCATION`, `VERTEX_MODEL`)
AWS Bedrock	`AWS_REGION` + `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` (+ optional `BEDROCK_MODEL_ID`)
Mistral	`MISTRAL_API_KEY`
Ollama (local)	`OLLAMA_HOST` (+ optional `OLLAMA_MODEL`)
Any OpenAI-compatible	`OPENAI_COMPATIBLE_BASE_URL` + `OPENAI_COMPATIBLE_MODEL` (+ optional `_API_KEY`, `_NAME`) — Together, Groq, DeepSeek, OpenRouter, Fireworks, Perplexity, Anyscale, vLLM, LiteLLM

Supported Providers

OpenAI, Anthropic, Google Gemini, Mistral, Ollama, Azure OpenAI, and any OpenAI-compatible endpoint (Together, Groq, DeepSeek, OpenRouter, Fireworks, Perplexity, Anyscale, vLLM, LiteLLM).

Documentation

In-repo feature guides (with detailed run steps) live in docs/:

Architecture — illustrated layer stack, request/graph/queue flows, HITL, MCP transports, and interfaces (on the docs site)
Sandbox backends — Process, Container, WASM (WASI), and Kubernetes Job isolation
MCP transports — connect to MCP servers over stdio and HTTP+SSE
Eval suites — declare and run evaluation suites from YAML or Go

Full docs at spawn08.github.io/chronos:

Installation — CLI binary, Go module, build from source
CLI Install — curl install for all platforms
Quickstart — First agent in 5 minutes
Agents — Agent builder, YAML config, capabilities
Teams — Multi-agent orchestration strategies
StateGraph — Durable execution with checkpointing
Tools — Function calling and permissions
Hooks — Middleware: retry, cache, cost, rate limit
Storage — All 10 storage and vector adapters

Server & API

chronos serve [addr] (default :8420) starts ChronosOS — the control-plane HTTP server. It exposes a REST API over sessions, checkpoints, traces, schedules, and human-in-the-loop approvals, plus a live SSE event stream, Prometheus metrics, health/readiness probes, and an interactive Swagger UI. It is hardened by default (timeouts, body limits, panic recovery, CORS, rate limiting, graceful shutdown) and stateless, so you can run many replicas behind a load balancer.

chronos serve :8420
open http://localhost:8420/swagger/     # interactive API explorer

Authentication is opt-in (CHRONOS_AUTH=none|jwt|apikey) with JWT (HS256/RS256/JWKS/OIDC) or API keys and per-tenant isolation. Role enforcement is opt-in too (CHRONOS_RBAC=true → admin > user > viewer), and the Swagger UI can be disabled on hardened deployments with CHRONOS_SWAGGER=false.

ChronosOS Server — start, configure, and operate the control plane
REST API Reference — every endpoint with curl examples
Authentication & Authorization — JWT, API keys, RBAC, tenants
Swagger UI at /swagger/ · OpenAPI JSON at /swagger/doc.json

Roadmap

Active development tracked in ROADMAP.md. Key upcoming work:

Priority	Area	Status
P0	Bug fixes, CLI wiring, test foundation	5/16 done
P1	MCP support, subgraphs, time travel, advanced HITL	Planned
P2	A2A protocol, cron triggers, multi-modal, graph visualization	Planned
P3	Workflow DSL, plugin marketplace, distributed execution	Planned

What's Next (P1 highlights)

MCP (Model Context Protocol) — Connect to MCP servers, use MCP tools natively
Subgraphs — Compose graphs as nodes, parallel fan-out/fan-in with state reducers
Time Travel — Replay from any checkpoint, fork execution with modified state
Advanced Streaming — Multiple stream modes (values, updates, debug), custom event emission
Structured Output — Response models with automatic validation and retry
Agentic Loops — ReAct, iterative refinement, self-correcting tool call patterns

CI/CD

Workflow	Trigger	What it does
CI	Push/PR to `main`	Lint, build, test (Ubuntu + macOS), example smoke tests, Docker build
Release	Tag `v..*`	Test gate, build 6 platform binaries, create GitHub Release with checksums, publish Go module, push Docker image to GHCR

Cut a release: git tag v0.2.0 && git push origin v0.2.0

Contributing

Fork and create a feature branch from main
Follow Go conventions — go vet, gofmt, wrap errors with %w
No init() functions, no global state, context.Context first on I/O methods
Table-driven tests in *_test.go files

License

MIT

Directories ¶

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

Path	Synopsis
cli Chronos CLI entry point.	Chronos CLI entry point.
cmd Package cmd provides the Chronos CLI command tree.	Package cmd provides the Chronos CLI command tree.
repl Package repl provides an interactive REPL for the Chronos CLI.	Package repl provides an interactive REPL for the Chronos CLI.
engine
graph Package graph provides the StateGraph durable execution runtime.	Package graph provides the StateGraph durable execution runtime.
guardrails Package guardrails provides input/output validation for agent execution.	Package guardrails provides input/output validation for agent execution.
hooks Package hooks provides a middleware system for intercepting agent execution events.	Package hooks provides a middleware system for intercepting agent execution events.
interop/mcpserver Package mcpserver exposes Chronos tools to any Model Context Protocol (MCP) host — Claude Desktop, IDEs, and other agent frameworks — over JSON-RPC 2.0.	Package mcpserver exposes Chronos tools to any Model Context Protocol (MCP) host — Claude Desktop, IDEs, and other agent frameworks — over JSON-RPC 2.0.
mcp Package mcp implements the Model Context Protocol (MCP) client.	Package mcp implements the Model Context Protocol (MCP) client.
model Package model defines pluggable LLM provider interfaces.	Package model defines pluggable LLM provider interfaces.
queue Package queue provides a durable, distributed work queue for Chronos graph runs.	Package queue provides a durable, distributed work queue for Chronos graph runs.
stream Package stream provides event streaming for real-time observability.	Package stream provides event streaming for real-time observability.
tool Package tool provides the tool registry with permissions and approval hooks.	Package tool provides the tool registry with permissions and approval hooks.
tool/builtins Package builtins provides ready-to-use tool implementations.	Package builtins provides ready-to-use tool implementations.
evals Package evals provides an evaluation framework for testing agent quality.	Package evals provides an evaluation framework for testing agent quality.
examples
a2a_interop command Example: a2a_interop shows Chronos interoperating over the Agent-to-Agent (A2A) protocol (WC-B-001).	Example: a2a_interop shows Chronos interoperating over the Agent-to-Agent (A2A) protocol (WC-B-001).
agui_stream command Example: agui_stream shows Chronos runs surfaced as a standard AG-UI event stream (WC-B-003).	Example: agui_stream shows Chronos runs surfaced as a standard AG-UI event stream (WC-B-003).
azure command Azure OpenAI example for Chronos.	Azure OpenAI example for Chronos.
azure_rag command Azure OpenAI RAG (retrieval-augmented generation) example for Chronos.	Azure OpenAI RAG (retrieval-augmented generation) example for Chronos.
azure_tools command Azure OpenAI tool-calling example for Chronos.	Azure OpenAI tool-calling example for Chronos.
chat_with_tools command Example: chat_with_tools demonstrates an agent that uses tools during chat.	Example: chat_with_tools demonstrates an agent that uses tools during chat.
cli_agent command Command custom_tool shows how to give a Chronos agent a CUSTOM tool with a real Go handler.	Command custom_tool shows how to give a Chronos agent a CUSTOM tool with a real Go handler.
coding_agent command Example: coding_agent — A full-featured autonomous coding agent.	Example: coding_agent — A full-featured autonomous coding agent.
context_compaction command Example: context_compaction demonstrates automatic context compaction (WC-A-004).	Example: context_compaction demonstrates automatic context compaction (WC-A-004).
data_residency command Data residency example for Chronos.	Data residency example for Chronos.
deep_agent command Example: deep_agent demonstrates the batteries-included "deep agent" harness preset (WC-A-005).	Example: deep_agent demonstrates the batteries-included "deep agent" harness preset (WC-A-005).
durable_hitl command Example: durable_hitl demonstrates a durable, human-in-the-loop (HITL) StateGraph.	Example: durable_hitl demonstrates a durable, human-in-the-loop (HITL) StateGraph.
durable_llm_graph command Example: durable_llm_graph — where LLM calls happen, and how the StateGraph runtime makes them durable.	Example: durable_llm_graph — where LLM calls happen, and how the StateGraph runtime makes them durable.
durable_queue command Command durable_queue demonstrates the Chronos durable, distributed execution plane (engine/queue) delivered in Phase P1.	Command durable_queue demonstrates the Chronos durable, distributed execution plane (engine/queue) delivered in Phase P1.
enterprise_sso command Enterprise SSO example for Chronos.	Enterprise SSO example for Chronos.
eval_loop command Example: eval_loop demonstrates the eval-driven development loop (WC-C-001): capture a dataset from a real run, run it against an agent target, score it, and gate on regressions — the trace → dataset → eval → gate cycle.	Example: eval_loop demonstrates the eval-driven development loop (WC-C-001): capture a dataset from a real run, run it against an agent target, score it, and gate on regressions — the trace → dataset → eval → gate cycle.
fallback_provider command Example: fallback_provider demonstrates automatic failover between model providers.	Example: fallback_provider demonstrates automatic failover between model providers.
graph_patterns command Example: graph_patterns demonstrates the StateGraph durable execution engine.	Example: graph_patterns demonstrates the StateGraph durable execution engine.
graph_with_llm command Example: graph_with_llm — StateGraph with real LLM calls inside nodes.	Example: graph_with_llm — StateGraph with real LLM calls inside nodes.
hooks_observability command Example: hooks_observability demonstrates all Chronos hooks for production observability.	Example: hooks_observability demonstrates all Chronos hooks for production observability.
internal/exampletest Package exampletest provides helpers for tests under examples/.	Package exampletest provides helpers for tests under examples/.
internal/providers Package providers is a shared helper used by the runnable examples to pick an LLM provider from the environment.	Package providers is a shared helper used by the runnable examples to pick an LLM provider from the environment.
k8s_sandbox command Example: k8s_sandbox runs an untrusted command as a one-shot Kubernetes Job using the K8s sandbox backend.	Example: k8s_sandbox runs an untrusted command as a one-shot Kubernetes Job using the K8s sandbox backend.
mcp_agent command Example: mcp_agent demonstrates connecting an agent to a Model Context Protocol (MCP) server and importing its tools into the agent's registry.	Example: mcp_agent demonstrates connecting an agent to a Model Context Protocol (MCP) server and importing its tools into the agent's registry.
mcp_server command Example: mcp_server exposes Chronos tools to any MCP host (Claude Desktop, an IDE, another agent framework) over stdio (WC-B-002).	Example: mcp_server exposes Chronos tools to any MCP host (Claude Desktop, an IDE, another agent framework) over stdio (WC-B-002).
mcp_sse command Example: mcp_sse connects an MCP client to a server over the HTTP+SSE transport (MCP 2024-11-05).	Example: mcp_sse connects an MCP client to a server over the HTTP+SSE transport (MCP 2024-11-05).
memory_and_sessions command Example: memory_and_sessions demonstrates persistent multi-turn sessions and the memory system (short-term + long-term).	Example: memory_and_sessions demonstrates persistent multi-turn sessions and the memory system (short-term + long-term).
multi_agent command Example: multi_agent demonstrates all four team strategies and agent communication.	Example: multi_agent demonstrates all four team strategies and agent communication.
multi_provider command Example: multi_provider demonstrates connecting agents to different LLM providers.	Example: multi_provider demonstrates connecting agents to different LLM providers.
multi_round_tools command Example: multi_round_tools demonstrates an agent performing MULTIPLE sequential tool-calling rounds, where the result of tool A feeds the arguments of tool B.	Example: multi_round_tools demonstrates an agent performing MULTIPLE sequential tool-calling rounds, where the result of tool A feeds the arguments of tool B.
multitenancy command Example: multitenancy demonstrates storage-level tenant isolation using storage.WithTenant.	Example: multitenancy demonstrates storage-level tenant isolation using storage.WithTenant.
multitenant_memory command Example: multitenant_memory demonstrates per-user long-term memory isolation — two different users served by one logical agent, whose memories never leak across tenants.	Example: multitenant_memory demonstrates per-user long-term memory isolation — two different users served by one logical agent, whose memories never leak across tenants.
planning_agent command Example: planning_agent demonstrates the built-in planning ("todo") tool (WC-A-001).	Example: planning_agent demonstrates the built-in planning ("todo") tool (WC-A-001).
quickstart command Chronos Quickstart — a minimal agent with SQLite storage and a durable StateGraph.	Chronos Quickstart — a minimal agent with SQLite storage and a durable StateGraph.
rag_knowledge command Example: rag_knowledge — Retrieval-Augmented Generation with the Knowledge API.	Example: rag_knowledge — Retrieval-Augmented Generation with the Knowledge API.
sandbox_execution command Example: sandbox_execution demonstrates the process sandbox for running untrusted commands with timeouts and output capture.	Example: sandbox_execution demonstrates the process sandbox for running untrusted commands with timeouts and output capture.
semantic_recall command Example: semantic_recall — automatic semantic long-term recall (WC-D-001).	Example: semantic_recall — automatic semantic long-term recall (WC-D-001).
server_embedded command Example: server_embedded — running the ChronosOS control plane as a library.	Example: server_embedded — running the ChronosOS control plane as a library.
skills command Example: skills — registering, listing, and resolving skills.	Example: skills — registering, listing, and resolving skills.
streaming_sse command Example: streaming_sse demonstrates the event streaming broker for real-time observability.	Example: streaming_sse demonstrates the event streaming broker for real-time observability.
structured_output command Example: structured_output — asking an LLM for strict JSON and decoding it.	Example: structured_output — asking an LLM for strict JSON and decoding it.
subagents command Example: subagents demonstrates context-isolated delegation (WC-A-003).	Example: subagents demonstrates context-isolated delegation (WC-A-003).
team_deploy command Example: team_deploy — Deploy multi-agent teams from YAML with sandbox isolation.	Example: team_deploy — Deploy multi-agent teams from YAML with sandbox isolation.
tools_and_guardrails command Example: tools_and_guardrails demonstrates the tool registry with permission levels and guardrail engine for input/output validation.	Example: tools_and_guardrails demonstrates the tool registry with permission levels and guardrail engine for input/output validation.
vertex command Google Cloud Vertex AI example for Chronos.	Google Cloud Vertex AI example for Chronos.
vfs_agent command Example: vfs_agent demonstrates the virtual filesystem for context offloading (WC-A-002).	Example: vfs_agent demonstrates the virtual filesystem for context offloading (WC-A-002).
wasm_sandbox command Example: wasm_sandbox runs an untrusted WebAssembly (WASI) module inside the pure-Go wazero-backed sandbox.	Example: wasm_sandbox runs an untrusted WebAssembly (WASI) module inside the pure-Go wazero-backed sandbox.
os Package chronosos provides the ChronosOS control plane server.	Package chronosos provides the ChronosOS control plane server.
apidocs Package apidocs Code generated by swaggo/swag.	Package apidocs Code generated by swaggo/swag.
approval Package approval provides human-in-the-loop approval workflows for the ChronosOS control plane.	Package approval provides human-in-the-loop approval workflows for the ChronosOS control plane.
auth Package auth provides authentication and RBAC for ChronosOS.	Package auth provides authentication and RBAC for ChronosOS.
interfaces/discord Package discord provides a Discord bot interface for Chronos agents.	Package discord provides a Discord bot interface for Chronos agents.
interfaces/slack Package slack provides a Slack bot interface for Chronos agents.	Package slack provides a Slack bot interface for Chronos agents.
interfaces/telegram Package telegram provides a Telegram bot interface for Chronos agents.	Package telegram provides a Telegram bot interface for Chronos agents.
interop/agui Package agui exposes Chronos runs as a standard AG-UI event stream, so any AG-UI-compatible frontend can render an agent run (steps, tool calls, plan updates, state snapshots, interrupts, completion) without Chronos-specific glue.	Package agui exposes Chronos runs as a standard AG-UI event stream, so any AG-UI-compatible frontend can render an agent run (steps, tool calls, plan updates, state snapshots, interrupts, completion) without Chronos-specific glue.
logging Package logging provides structured JSON-line logging with correlation and tenant identifiers carried through context.	Package logging provides structured JSON-line logging with correlation and tenant identifiers carried through context.
metrics Package metrics provides Prometheus-format metrics collection and export.	Package metrics provides Prometheus-format metrics collection and export.
middleware Package middleware provides HTTP middleware for ChronosOS.	Package middleware provides HTTP middleware for ChronosOS.
scheduler Package scheduler provides cron-based scheduling for agent runs.	Package scheduler provides cron-based scheduling for agent runs.
trace Package trace provides execution tracing and audit logging.	Package trace provides execution tracing and audit logging.
webhook Package webhook provides a generic webhook interface for receiving external events.	Package webhook provides a generic webhook interface for receiving external events.
sandbox Package sandbox provides isolation for untrusted tool/skill execution.	Package sandbox provides isolation for untrusted tool/skill execution.
sdk
agent Package agent provides the agent definition and builder API.	Package agent provides the agent definition and builder API.
harness Package harness provides agent-harness orchestration primitives that compose over the SDK agent loop — context-isolated and dynamic subagents, and the "deep agent" preset that assembles them with planning (WC-A-001) and the virtual filesystem (WC-A-002).	Package harness provides agent-harness orchestration primitives that compose over the SDK agent loop — context-isolated and dynamic subagents, and the "deep agent" preset that assembles them with planning (WC-A-001) and the virtual filesystem (WC-A-002).
knowledge Package knowledge provides a RAG knowledge base abstraction inspired by Agno's Knowledge protocol.	Package knowledge provides a RAG knowledge base abstraction inspired by Agno's Knowledge protocol.
knowledge/loaders Package loaders provides document loaders for different file formats.	Package loaders provides document loaders for different file formats.
memory Package memory — manager.go provides an LLM-powered memory manager inspired by Agno's MemoryManager.	Package memory — manager.go provides an LLM-powered memory manager inspired by Agno's MemoryManager.
protocol Package protocol defines the agent-to-agent communication protocol.	Package protocol defines the agent-to-agent communication protocol.
protocol/a2a Package a2a implements the Agent-to-Agent (A2A) protocol for cross-framework agent communication.	Package a2a implements the Agent-to-Agent (A2A) protocol for cross-framework agent communication.
skill Package skill provides the skill/plugin system for Chronos agents.	Package skill provides the skill/plugin system for Chronos agents.
team Package team provides multi-agent orchestration with inter-agent communication.	Package team provides multi-agent orchestration with inter-agent communication.
skills
examples Package examples provides example skill definitions.	Package examples provides example skill definitions.
storage Package storage defines the core persistence interfaces for Chronos.	Package storage defines the core persistence interfaces for Chronos.
adapters/chromadb Package chromadb provides a ChromaDB-backed VectorStore adapter for Chronos.	Package chromadb provides a ChromaDB-backed VectorStore adapter for Chronos.
adapters/dynamo Package dynamo provides a DynamoDB-backed Storage adapter for Chronos.	Package dynamo provides a DynamoDB-backed Storage adapter for Chronos.
adapters/lancedb Package lancedb provides a LanceDB-backed VectorStore adapter for Chronos.	Package lancedb provides a LanceDB-backed VectorStore adapter for Chronos.
adapters/memory Package memory provides an in-memory Storage adapter for Chronos.	Package memory provides an in-memory Storage adapter for Chronos.
adapters/milvus Package milvus provides a Milvus-backed VectorStore adapter for Chronos.	Package milvus provides a Milvus-backed VectorStore adapter for Chronos.
adapters/mongo Package mongo provides a MongoDB-backed Storage adapter for Chronos.	Package mongo provides a MongoDB-backed Storage adapter for Chronos.
adapters/pgvector Package pgvector provides a PostgreSQL+pgvector-backed VectorStore adapter for Chronos.	Package pgvector provides a PostgreSQL+pgvector-backed VectorStore adapter for Chronos.
adapters/pinecone Package pinecone provides a Pinecone-backed VectorStore adapter for Chronos.	Package pinecone provides a Pinecone-backed VectorStore adapter for Chronos.
adapters/postgres Package postgres provides a PostgreSQL-backed Storage adapter for Chronos.	Package postgres provides a PostgreSQL-backed Storage adapter for Chronos.
adapters/qdrant Package qdrant provides a Qdrant-backed VectorStore adapter for Chronos.	Package qdrant provides a Qdrant-backed VectorStore adapter for Chronos.
adapters/redis Package redis provides a Redis-backed Storage adapter for Chronos.	Package redis provides a Redis-backed Storage adapter for Chronos.
adapters/redisvector Package redisvector provides a Redis-backed VectorStore adapter using the RediSearch module (Redis Stack) for KNN vector similarity search.	Package redisvector provides a Redis-backed VectorStore adapter using the RediSearch module (Redis Stack) for KNN vector similarity search.
adapters/sqlite Package sqlite provides a SQLite-backed Storage adapter for Chronos.	Package sqlite provides a SQLite-backed Storage adapter for Chronos.
adapters/weaviate Package weaviate provides a Weaviate-backed VectorStore adapter for Chronos.	Package weaviate provides a Weaviate-backed VectorStore adapter for Chronos.
migrate Package migrate provides versioned database migrations for SQL backends.	Package migrate provides versioned database migrations for SQL backends.