> ## Documentation Index
> Fetch the complete documentation index at: https://docs.multimind.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# MultiMind SDK - Feature Status

This document provides an honest status of all features in MultiMind SDK. Each feature is marked with one of three status badges:

* ✅ **Stable**: Production-ready, fully tested, and working
* 🚧 **Beta**: Functional but may have limitations or missing features
* 📋 **Planned**: Not yet implemented or placeholder only

***

## 🧠 Core AI Model Management

### Model Integrations

* ✅ **OpenAI Integration** (`OpenAIModel`) - Full API support with GPT-3.5, GPT-4, embeddings
  * Example: `examples/api/model_wrapper.py`
* ✅ **Claude Integration** (`ClaudeModel`) - Anthropic API support
  * Example: `examples/api/model_wrapper.py`
* ✅ **Ollama Integration** (`OllamaModel`) - Local model support
  * Example: `examples/cli/chat_ollama_cli.py`
* ✅ **Mistral Integration** - `MistralAIModel` (direct Mistral API) and `MistralModel` (local via Ollama)
* ✅ **OpenRouter Integration** (`OpenRouterModel`) - 300+ models from dozens of providers via one API key
* ✅ **Together AI Integration** (`TogetherModel`) - Open-weight models with embeddings support
* ✅ **xAI Integration** (`XAIModel`) - Grok models
* ✅ **Perplexity Integration** (`PerplexityModel`) - Sonar online models
* ✅ **Fireworks AI Integration** (`FireworksModel`) - Open-weight models with embeddings support
* ✅ **Cerebras Integration** (`CerebrasModel`) - Fast inference on Cerebras hardware
* ✅ **100+ Model Support** - 13 first-party providers (OpenAI, Claude, Gemini, Groq, Mistral, DeepSeek, Ollama, OpenRouter, Together, xAI, Perplexity, Fireworks, Cerebras) plus 300+ models via OpenRouter aggregation

### Model Features

* ✅ **Vision/Multimodal Input** - `images=` on `generate`/`chat` for OpenAI-compatible providers (content-parts with base64 data URLs or URLs) and Claude (base64/URL image blocks); providers without a vision-capable endpoint raise `NotImplementedError`
  * Example: `examples/models/vision_demo.py`
* ✅ **Multi-Model Wrapper** - Unified interface for multiple models
  * Example: `examples/api/multi_model_wrapper.py`
* ✅ **Model Routing** - Basic routing between models
  * Example: `examples/api/ensemble_api.py`
* ✅ **Model Sessions** (`ModelSession`, `multimind/client/model_session.py`) - Stateful chat over any BaseLLM-compatible model (including guard-wrapped ones) with history, a rolling summary when the token budget is exceeded, and `switch(model, strategy=...)` to move a conversation to another model using `full`, `summary`, or `adapted` transfer; every switch is logged in `transfers`
  * Tests: `tests/test_model_session.py`
* ✅ **Context Transfer** (`multimind.context_transfer`, `multimind context-transfer`) - Reformats a saved conversation from one provider into a prompt for another with last-N extraction, concise/detailed/structured summaries, and provider adapters; the CLI's `--list_models`, `--model_info`, argument validation, and missing-file paths are tested. Two tests for private formatter methods that no longer exist are skipped, not failing
  * Tests: `tests/test_context_transfer.py`, `tests/test_context_transfer_integration.py`, `tests/test_cli.py`
* 🚧 **Model Conversion** (`ModelConversionManager`, `multimind convert`) - HuggingFace/PyTorch/TensorFlow/ONNX/Ollama sources to GGUF/Safetensors/TFLite/ORT/ONNX targets; needs the `[finetune]` extra (torch). Only the CLI's no-torch failure path is tested; the converters themselves have no automated coverage, so this stays Beta
  * Tests: `tests/test_cli.py` (`test_convert_without_torch_fails_cleanly`)
* 🚧 **Mixture-of-Experts (MoE)** - Basic implementation. `MoEFactory.create_model` was passing its config dict positionally into `MoEModel(config)` instead of unpacking it as keyword arguments, so model creation via the factory was broken; fixed. Edge-case tests added for config validation and (torch-gated) routing/capacity behavior; stays Beta pending fuller real-model coverage
  * Example: `examples/moe/`
  * Tests: `tests/test_moe_edge_cases.py`
* 🚧 **Model Compression** - Basic quantization support. Fixed a real bug where dynamic quantization's result was discarded: `torch.quantization.quantize_dynamic()` returns a new module rather than mutating in place, so the quantized layer was never actually installed on the model. Edge-case tests added (torch-gated; this venv has no torch so they run in CI's torch job); stays Beta pending broader real-model coverage
  * Tests: `tests/test_model_compression_edge_cases.py`
* 📋 **Federated Learning** - Not implemented
* 📋 **Model Watermarking** - Not implemented

***

## 📚 Vector Databases & RAG

### Vector Store Backends

#### ✅ **Core** (Recommended, most exercised)

* ✅ **FAISS** - Fully functional local vector store, now with real add/search/delete/persist/load round-trip integration tests (example: `examples/vector_store/`)
* ✅ **Chroma** - Complete implementation with metadata support (example: `examples/rag/rag_example.py`)
* ✅ **Pinecone**, **Qdrant**, **Weaviate**, **Milvus**, **Zilliz**
* ✅ **Elasticsearch**, **OpenSearch**, **MongoDB Atlas**
* ✅ **PGVector**, **PGVectoRS**, **PGEmbedding** (PostgreSQL family)
* ✅ **Annoy**, **sklearn**, **SQLiteVSS**, **LanceDB** - fixed real bugs that made Annoy/sklearn/SQLiteVSS impossible to even instantiate (missing the required `initialize()` override) or return correct results (SQLiteVSS's query syntax and an empty-table crash in its underlying native library; a missing `vector` field on sklearn's and SQLiteVSS's search results; Annoy losing index density after deletes). All four now have real add/search/delete round-trip integration tests
  * Tests: `tests/integration/test_vector_stores_live.py` (`pytest -m integration`), `tests/integration/README.md`

#### 🚧 **Client-backed** (Real implementations, less battle-tested)

AlibabaCloud OpenSearch, AnalyticDB, AstraDB, Hippo, Hologres, Marqo, Matching Engine,
Meilisearch, Momento, MyScale, Neo4j Vector, NucliaDB, Rockset, SingleStoreDB, StarRocks,
Supabase, Tair, TencentVectorDB, Tigris, TimescaleVector, Typesense, USearch, Vald,
Vectara, Xata, Zep — each calls its actual client library and returns real results.

Partially implemented (unsupported operations raise `NotImplementedError`):
Cassandra (no search), Azure AI Search / Azure Cosmos DB (no vector search),
LLMRails (no delete), TileDB (no delete).

#### 📋 **Not Implemented** (all methods raise `NotImplementedError`)

AwaDB, BagelDB, BaiduCloud, Clarifai, ClickHouse, DashVector, Databricks Vector Search,
DeepLake, DingoDB, Elastic Vector Search (legacy module), Epsilla

> **Note**: \~44 of the \~60 backends are real client-library-backed implementations.
> The 11 unimplemented ones raise `NotImplementedError` immediately — no backend
> silently pretends to work.

### RAG Features

* ✅ **Basic RAG Pipeline** - Core RAG implementation with document processing
  * Example: `examples/rag/rag_example.py`
* ✅ **Document Processing** - Text splitting and basic processing
  * Example: `examples/rag/rag_example.py`
* ✅ **Embedding Management** - Basic embedding support
* 🚧 **Advanced RAG** - Enhanced retrieval with metadata filtering. Edge-case tests added for `Retriever`/`EnhancedRetriever`/`HybridRetriever` (malformed filters, empty corpus, oversized k, fusion-weight/feedback behavior); stays Beta pending broader coverage
  * Example: `examples/rag/rag_advanced_example.py`
  * Tests: `tests/test_advanced_rag_edge_cases.py`
* ✅ **Hybrid RAG Architecture** - `GraphRetriever` builds an entity/relation graph via LLM extraction (`GraphRAG`) and ranks documents by query-entity overlap plus one-hop neighbor expansion
  * Example: `tests/test_graph_retrieval.py`
* 📋 **Quantum-Enhanced Search** - Quantum algorithms not implemented
* 🚧 **Multi-Modal Document Processing** - Table extraction implemented (pdfplumber for PDFs, pandas for pre-parsed rows); image extraction does OCR via pytesseract (`[documents]` extra) with no object detection/captioning (no vision model configured); LLM-based structure analysis remains a placeholder

***

## 🤖 AI Agents

### Agent Framework

* ✅ **Basic Agents** - `Agent` class with real native function-calling: builds JSON-schema tool definitions from registered tools, executes returned `tool_calls` in a bounded loop (`max_turns`), and feeds results back to the model — used automatically when the model exposes an OpenAI-compatible client; falls back to keyword-based tool routing otherwise (duck-typed detection)
  * Example: `examples/cli/basic_agent.py`
* ✅ **Agent Registry** - Agent registration and management
  * Example: `examples/agents/agent_registry_example.py`
* ✅ **ReAct Toolchain** - ReAct pattern implementation
  * Example: `examples/agents/react_toolchain_example.py`
* 🚧 **Multi-Agent Orchestration** - Basic coordination
* ✅ **Self-Evolving Agents** (bounded) - `SelfEvolvingAgent` records task outcomes and injects the top-utility few-shot exemplars into future prompts; utility rises on success and decays on failure. Bound: no self-modification of code or prompts beyond exemplar selection
  * Example: `tests/test_self_evolving.py`
* ✅ **Cognitive Scratchpad** - Step dependencies (`add_step_dependency`, cycle-checked) and revision history (`revise_step`/`get_revision_history`) added on top of the existing LLM-based reasoning-chain tracking
  * Example: `tests/test_cognitive_scratchpad.py`

***

## 🧠 Memory Systems

### ✅ **Stable** Memory Types

* ✅ **Buffer Memory** - Working conversation buffer
* ✅ **Summary Memory** - Working summarization
* ✅ **Summary Buffer Memory** - Hybrid summary + buffer
* ✅ **Agent Memory** - Agent state management
  * Example: `examples/memory/basic_usage.py`
* ✅ **Vector Store Memory** - Real add/get/search/clear/save-load round-trips against a live FAISS backend, with correct similarity ordering. Fixed real bugs: the default config crashed on construction (passed kwargs the real `VectorStoreConfig` doesn't accept), several call sites read config values as attributes that don't exist on `VectorStoreConfig` (now uses `.get(...)`), the embedding call used a nonexistent `BaseLLM` method name, and `VectorStore.load()` discarded the backend instance its own `load()` classmethod returned. Known limitation: the FAISS backend ignores `filter_criteria`, so `get(memory_id)` isn't reliable once more than one vector is stored
  * Tests: `tests/test_memory_beta.py`
* ✅ **Episodic Memory** - Real add/retrieve round-trips through the spatial/temporal/emotional indices, episode chaining, and save/load persistence. Fixed real bugs: a `len()` called on an int in `get_episode_suggestions`, chain-list mutation of a predecessor's own stored list, sets not JSON-serializable on save (and not restored as sets on load), and self-similarity inflating episode chaining
  * Tests: `tests/test_memory_beta.py`
* ✅ **Semantic Memory** - Real concept-extraction, relationship-inference, and save/load round-trips. Fixed real bugs: a missing `await` on `embeddings()` during `load()` (silently storing coroutine objects instead of vectors), sets not JSON-serializable on save, and self-similarity inflating relationship inference
  * Tests: `tests/test_memory_beta.py`
* ✅ **Procedural Memory** - Real procedure-extraction, `record_execution`/adaptation, and save/load round-trips. Fixed real bugs: two methods named `get_procedure_stats`/`get_procedure_suggestions` in the same class silently shadowed each other, so `super().get_procedure_stats()` in the subclass resolved to a nonexistent parent method instead of the intended base implementation (renamed the base versions); a missing `await` on `embeddings()` during `load()`; sets not JSON-serializable on save
  * Tests: `tests/test_memory_beta.py`
* ✅ **Hybrid Memory** - Real routing across two live child memories (both full- and partial-routing cases), `get_hybrid_stats`, and save/load round-trips. Fixed a real bug: `load()` restored the hybrid bookkeeping but never reloaded each child memory's own persisted content, so reloaded child memories came back empty
  * Example: `examples/memory/advanced_memory_manager.py`
  * Tests: `tests/test_memory_beta.py`

### 📋 **Planned/Experimental** Memory Types

* 📋 **Quantum Memory** - Simulation code only (not real quantum computing)
  * Note: This is a classical simulation, not actual quantum hardware
  * Example: `examples/memory/quantum_memory.py` (for educational purposes)
* 🚧 **Consensus Memory** - Local in-process replication with majority-vote reads; networked RAFT (elections, RPCs) not implemented and raises `NotImplementedError`
* ✅ **Planning Memory** - Plan-step recording plus success-weighted next-step suggestion from historical state/action outcomes (same style as `ReinforcementMemory`); the old fake multi-step "rollout" simulation (fabricated outcomes, no real environment) was removed rather than kept as invented output
  * Example: `tests/test_planning_memory.py`
* 🚧 **Declarative Memory** - Fact storage with timestamp-based temporal relations, lexical-cue causal heuristics, and knowledge-graph updates (delegates to a configured graph memory, else a plain dict graph); verification/consistency/reasoning analyses depend on a JSON-capable LLM
* 🚧 **Implicit Memory** - Skill tracking with prerequisite graph and practice-based proficiency
* 🚧 **Reinforcement Memory** - Pure-python tabular Q-learning for budget management (keep/evict/compress)
* 🚧 **Generative Memory** - Regeneration bookkeeping, drift tracking, and due-memory regeneration via a caller-supplied generator
* 🚧 **Active Learning Memory** - Explicit feedback loop: per-memory utility scores, utility-weighted recency retrieval, low-utility eviction

***

## 🔄 Fine-Tuning & Model Training

### Fine-Tuning Features

* 🚧 **Basic LoRA** - Basic LoRA support
  * Example: `examples/fine_tuning/`
* 🚧 **Adapter Training** - Basic adapter support
* 🚧 **Non-Transformer Models** - Mamba and RWKV run real inference (HuggingFace-backed); the other listed architectures (Hyena, S4 variants, RetNet, H3, MLP-only, diffusion-text, etc.) are extension scaffolds only and raise `NotImplementedError`
  * Example: `examples/non_transformer/`
* 🚧 **QLoRA** - Real 4-bit NF4 quantization + LoRA adapters via transformers/peft/bitsandbytes (`[finetune-gpu]` extra); raises `NotImplementedError` when those deps are absent. Compacter remains a scaffold (peft ships no Compacter config)
* 📋 **HyperLoRA** - Complex hypernetwork not implemented
* ✅ **RAG Fine-tuning** - `SyntheticQAGenerator` generates Q/A pairs from document chunks via strict-parsed LLM JSON, dedups by question hash, quality-filters by grounding score, and exports Alpaca-style instruction-tuning JSONL; pure Python, no torch required
  * Example: `tests/test_synthetic_data.py`
* 📋 **Advanced Optimization** - Many techniques not implemented

***

## 🔐 Compliance & Security

### ✅ **Stable** Compliance Features

* ✅ **Basic Compliance Framework** - Core compliance infrastructure
  * Example: `examples/compliance/healthcare_compliance_example.py`
* ✅ **Healthcare Compliance** - PHI tracking with audit-logged access, breach modeling, and state-based HIPAA/HITECH rule checks; requirements needing external systems report `unverifiable` instead of a fabricated pass
  * Example: `examples/compliance/healthcare/`
* ✅ **GDPR Runtime Enforcement** - `GDPRPolicy.check_processing(purpose, data_categories, consent, retention_days)` evaluates a concrete processing request against a configured lawful-basis/purpose-limitation/retention policy and returns an `allowed`/`denied`/`not_configured` decision with reasons; unknown purposes get an explicit `not_configured` denial rather than a guess. `gdpr_enforce(policy)` derives real `ComplianceGuard` settings from the policy (blocks special-category PII when no purpose permits sensitive data; `hash` vs `mask` redaction strategy from the pseudonymization setting), wiring the policy into the actual runtime guard
  * Tests: `tests/compliance/test_gdpr_enforcement.py`
* ✅ **Framework Governance Adapters** (`multimind.integrations.frameworks`) - Drop-in PII guard/budget/cost/audit wrappers for LangChain (`guard_runnable`, `guard_tool`/`guard_tools` for agent tool inputs, `MultiMindCallbackHandler` with `pii_detected` audit events since LangChain callbacks can't mutate prompts), LlamaIndex (`guard_llm`, `MultiMindLlamaIndexHandler`), CrewAI (`guard_crew_llm`, verified against installed crewai 1.15.1), AutoGen (`guard_autogen_client`, targets autogen-core's `ChatCompletionClient` ABC), Haystack (`guard_haystack_generator`, duck-typed — never imports `haystack`), and raw OpenAI clients (`guard_openai`, covers `chat.completions.create`, `responses.create`, and `embeddings.create`). All lazy-imported; a missing framework raises a `pip install ...` hint only when its adapter is used
  * Docs: `docs/integrations.md`
  * Tests: `tests/test_framework_adapters.py`, `tests/test_framework_adapter_autogen.py`, `tests/test_framework_adapter_haystack.py`
* ✅ **Guard Proxy** (`multimind serve`, `multimind/gateway/guard_proxy.py`) - OpenAI-compatible `/v1/chat/completions` and `/v1/embeddings` proxy in front of a named or custom upstream, with PII redaction (mask/hash/remove), `--block-on` rejection, budget enforcement, JSONL audit and cost logs, output scanning, and guardrails JSON hot-reload via `POST /v1/guardrails/reload`. Requires the `[gateway]` extra
  * Docs: `docs/guard-proxy.md`
  * Tests: `tests/test_guard_proxy.py`
* ✅ **Hallucination Detection** (`multimind/evaluation/hallucination.py`) - `HallucinationDetector` scores each response sentence against supplied sources (containment-based grounding) and, with a judge model, extracts and verifies claims; `GuardedModel` wraps any model and on a low grounding score annotates, raises `HallucinationError`, or retries; `detect_hallucinations()` is the one-call form. Malformed judge output raises `ValueError` rather than being guessed at
  * Tests: `tests/test_hallucination.py`
* ✅ **Evidence Reports** (`build_evidence_report`, `multimind compliance report-evidence`) - Markdown or self-contained HTML report built from the guard audit log, the cost log, and an inventory scan, mapped to EU AI Act / SOC 2 / HIPAA control themes. Absent inputs are stated as absent, never fabricated; the framework mapping shrinks to the sources present; rendering is deterministic
  * Tests: `tests/test_compliance_reporting.py`
* ✅ **Governance Dashboard** (`multimind dashboard`, `multimind/dashboard/server.py`) - Local read-only web UI and JSON API (`/api/summary`, `/api/audit`, `/api/costs`, `/api/inventory`, `/api/scan-text`, `/api/evidence-report`, `/api/guardrails`) over the audit trail, cost log, and inventory scan, plus a no-code guardrails editor whose file feeds `multimind serve --config`. Requires the `[gateway]` extra
  * Docs: `docs/dashboard.md`
  * Tests: `tests/test_dashboard.py`
* ✅ **MCP Server** (`python -m multimind.mcp_server`, `[mcp]` extra) - Anthropic Model Context Protocol server exposing `scan_text`, `redact_text`, `check_grounding`, `check_policy`, and `audit_log` tools to Claude Desktop, Claude Code, and other MCP clients; findings carry spans, never raw PII values. Importable without the MCP SDK and fails with an install hint only when started
  * Docs: `docs/mcp-server.md`
  * Tests: `tests/test_mcp_server.py`

### 🚧 **Beta** Compliance Features

* 🚧 **Data Governance** - Basic governance framework

### 📋 **Planned** Compliance Features

* 📋 **Zero-Knowledge Proofs** - `cryptography.zkp` import fails
* 📋 **Federated Shards** - `FederatedShard` class missing
* 📋 **Homomorphic Encryption** - Basic implementation only
* 📋 **Self-Healing Compliance** - Patch generation not implemented
* 📋 **Adaptive Privacy** - Feedback mechanisms not functional
* ✅ **Regulatory Change Detection** - `RegulatoryWatcher` (`multimind/compliance/regulatory_watch.py`) fetches source pages via httpx, hashes content, and reports `ChangeEvent`s with a raw unified diff on change — no fabricated legal interpretation; offline `check_offline()` mode for dry runs. Note: distinct from the pre-existing `RegulatoryChangeDetector` stub in `advanced.py`, which remains unimplemented
  * Example: `examples/compliance/regulatory_watch_demo.py`
* 📋 **Quantum-Safe Encryption** - Not implemented
* ✅ **Differential Privacy** - Laplace mechanism (`DPMechanism`) with epsilon-budget accounting (`PrivacyBudget`, `BudgetExhaustedError`) in `multimind/compliance/advanced.py`; composition is simple sequential (sum of epsilons per call) — (epsilon, delta)-advanced composition is not implemented

***

## 🔄 Workflow & Orchestration

### Workflow Features

* ✅ **Prompt Chains** - Basic chaining
  * Example: `examples/cli/prompt_chain.py`
* ✅ **Task Runner** - Simple task execution
  * Example: `examples/cli/task_runner.py`
* 🚧 **MCP (Model Composition Protocol)** - Basic executor and parser for MultiMind's internal workflow format. Note: this is not Anthropic's Model Context Protocol — that is supported via the `multimind-compliance` MCP server (`python -m multimind.mcp_server`, `[mcp]` extra, see `docs/mcp-server.md`).
  * Example: `examples/mcp_workflows/`
* 🚧 **Pipeline Builder** - Basic pipeline construction
  * Example: `examples/pipeline/pipeline_example.py`
* 📋 **Visual Workflow Builder** - Drag-and-drop not implemented
* 📋 **Event-Driven Architecture** - Reactive workflows not fully implemented
* 📋 **Advanced Workflow Automation** - Complex features missing

***

## 📊 Monitoring & Analytics

### Observability Features

* ✅ **Cost Tracking and Budgets** (`CostTracker`, `Budget`, `track_costs`, `multimind/observability/cost_tracker.py`) - Per-call cost records with real token usage when the provider exposes it (else a flagged estimate), pricing from the model's `cost_per_token` or `MODEL_PRICING` (unpriced models record `$0` and are flagged, never a made-up price), per-model/provider/tag summaries, optional JSONL persistence, and `Budget` that warns at a ratio and raises `BudgetExceededError` at the cap
  * Tests: `tests/test_cost_tracker.py`
* ✅ **Shadow-AI Inventory and Chargeback** (`scan_project`, `CostTracker.chargeback`, `multimind audit`) - Static scan of dependencies, API URLs, env-var reads, and hardcoded AI keys (reported by location, never by value) plus per-tag chargeback reports from the session tracker or a JSONL cost log
  * Docs: `docs/ai-inventory.md`
  * Tests: `tests/test_ai_inventory.py`, `tests/test_cost_tracker.py`
* ✅ **Run Tracing** (`RunTracer`, `trace_model`, `multimind/observability/tracing.py`) - Runs and nested spans for llm/chain/tool calls with latency, tokens, and cost, written to a local SQLite sink and/or exported to a self-hosted platform (`POST /api/v1/runs`, buffered retry on failure). Stores only character counts and SHA-256 hashes of prompts and responses unless `store_content=True` is passed
  * Docs: `docs/tracing.md`
  * Tests: `tests/test_tracing.py`
* 🚧 **Basic Logging** - TraceLogger and basic metrics
* 🚧 **Usage Tracking** - Basic usage tracking
  * Example: `examples/cli/usage_tracking.py`
* 📋 **Real-time Performance Tracking** - Microsecond-level monitoring not implemented
* 📋 **AI-Powered Anomaly Detection** - Not implemented
* 📋 **Cost Optimization Engine** - Intelligent allocation not implemented
* 📋 **Predictive Maintenance** - Not implemented

***

## 🛠️ CLI & API

### ✅ **Stable**

* ✅ **CLI Framework** - Click-based CLI with multiple commands
  * Docs: `docs/cli.md`; tests: `tests/test_cli.py`
* ✅ **Basic API** - REST API gateway
  * Example: `examples/api/gateway_examples.py`

### 🚧 **Beta**

* 🚧 **Advanced API Features** - Some features may be limited

***

## 📈 Test Coverage

Test counts are not kept on this page because they go stale; the [CI workflow](https://github.com/multimindlab/multimind-sdk/blob/develop/.github/workflows/ci.yml) publishes the current passed/skipped/failed numbers per Python version on every run, and the `test-full` job enforces a 95% pass-rate gate. Tests that need optional heavy dependencies or live services skip in the default suite; the integration suite runs with `pytest -m integration`.

***

## 🎯 Summary

### What Works Today (Production Ready)

* Multi-model AI chat across 13 first-party providers (OpenAI, Claude, Gemini, Groq, Mistral, DeepSeek, Ollama, OpenRouter, Together, xAI, Perplexity, Fireworks, Cerebras) plus 300+ models via OpenRouter aggregation, with vision/multimodal input
* Runtime PII guard, cost budgets, hallucination detection, and audit trails — one-line wrappers around any model
* Compliance proxy (`multimind serve`), governance dashboard (`multimind dashboard`), AI-usage audit/chargeback (`multimind audit`), and evidence reports mapped to EU AI Act / SOC 2 / HIPAA control themes
* Framework governance adapters for LangChain, LlamaIndex, CrewAI, AutoGen, Haystack, and raw OpenAI clients
* Anthropic MCP server exposing compliance tools, plus an OSS tracing client for a self-hosted observability platform
* Bounded agents with real native function-calling, tool-input scanning, and bounded self-evolving exemplar learning
* GDPR runtime enforcement (policy → guard wiring) and state-based HIPAA validation (never a fabricated pass)
* RAG (Retrieval-Augmented Generation) with hybrid knowledge-graph retrieval and synthetic Q/A generation for fine-tuning
* 5 Stable memory types (Episodic, Semantic, Procedural, Hybrid, Vector Store) plus Buffer/Summary/Agent memory
* \~44 real vector-database integrations (FAISS, Chroma, Pinecone, Qdrant, Weaviate, Milvus, and more)
* CLI interface (7 command groups) and REST gateway with Swagger UI
* Basic model conversion, fine-tuning (LoRA, real QLoRA), and context transfer between models

### What's In Development (Beta)

* Advanced vector database integrations (26 client-backed backends, less battle-tested than the Core set)
* MoE, model compression, and advanced RAG (edge-case tested this round; real bugs fixed, broader real-model coverage still pending)
* Consensus/Declarative/Implicit/Reinforcement/Generative/Active-Learning memory (all real, none fabricated — see Memory Systems for specifics)
* MCP workflows (Model Composition Protocol, MultiMind's internal workflow format — distinct from the Anthropic MCP server, which is Stable)

### What's Planned (Future)

* Quantum memory (real quantum hardware)
* 50+ additional vector database backends
* Zero-knowledge proofs, homomorphic encryption, model/federated-learning watermarking, self-healing compliance patch generation
* Visual workflow builder
* Advanced monitoring and analytics (real-time performance tracking, anomaly detection, cost optimization engine)

***

> **Honesty Note**: MultiMind SDK is actively being developed. While we have a solid foundation, many features described in marketing materials are still in development or planned. We're committed to transparency about what works today versus what's coming in the future. See [ROADMAP.md](https://github.com/multimindlab/multimind-sdk/blob/develop/ROADMAP.md) for our development priorities.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.