multimind-sdk 1.0.0

The compliance-first AI agent framework.
Multi-model AI with built-in GDPR and HIPAA support. Works with any model. Runs anywhere.

New to AI? Start with the plain-language getting started guide — no coding required.

Why MultiMind?

Most AI frameworks assume you'll handle compliance yourself. MultiMind doesn't.

• One API for all models — OpenAI, Anthropic Claude, Google Gemini, Mistral, Groq, DeepSeek, xAI, Together, Perplexity, Fireworks, Cerebras, 300+ models via OpenRouter, and local models via Ollama through a single async interface with streaming
• Built-in compliance — a drop-in PII guard that detects, redacts, and audits sensitive data on every model call, plus GDPR & HIPAA policy modeling and compliance dashboards as a first-class module, not an afterthought
• Govern the stack you already have — don't migrate off LangChain, LlamaIndex, or CrewAI; wrap them. Run multimind serve and point any OpenAI-compatible app at it to add PII redaction, budgets, and audit with one line changed
• Governed by default — cost budgets that stop overspending before the call, hallucination detection with sentence-level evidence, and audit trails — each a one-line wrapper around any model
• Switch models without losing knowledge — move a live conversation from GPT to Claude to a local model; the context travels with you
• Adaptive routing — route requests across providers by cost, latency, or fallback strategy
• RAG that works — FAISS and Chroma with document processing out of the box; 40+ client-backed vector stores including Pinecone, Qdrant, Weaviate, Milvus, pgvector, and LanceDB
• Beyond transformers — run Mamba and RWKV models through the same interface
• Runs anywhere — Cloud, on-prem, air-gapped with local models

Quick Start

pip install multimind-sdk

import asyncio
from multimind import OpenAIModel

async def main():
    model = OpenAIModel(model_name="gpt-4o-mini")
    response = await model.generate("Explain quantum computing simply")
    print(response)

asyncio.run(main())

Requires OPENAI_API_KEY in your environment. The same pattern works for ClaudeModel (Anthropic, ANTHROPIC_API_KEY), GeminiModel (Google, GEMINI_API_KEY), MistralAIModel (MISTRAL_API_KEY), GroqModel (GROQ_API_KEY), DeepSeekModel (DEEPSEEK_API_KEY), and OllamaModel (local models — Mistral, Llama, and anything else Ollama serves). Also: OpenRouterModel (OPENROUTER_API_KEY — 300+ models via one key), TogetherModel (TOGETHER_API_KEY), XAIModel (XAI_API_KEY), PerplexityModel (PERPLEXITY_API_KEY), FireworksModel (FIREWORKS_API_KEY), and CerebrasModel (CEREBRAS_API_KEY).

Install what you need

pip install multimind-sdk                # Core (incl. Ollama via HTTP, no extra needed)
pip install multimind-sdk[rag]           # + RAG & vector stores (FAISS, Chroma)
pip install multimind-sdk[agents]        # + Agent framework with memory
pip install multimind-sdk[compliance]    # + GDPR/HIPAA compliance + dashboards
pip install multimind-sdk[finetune]      # + LoRA/QLoRA fine-tuning (CPU)
pip install multimind-sdk[finetune-gpu]  # + 4-bit QLoRA via bitsandbytes (Linux only)
pip install multimind-sdk[gateway]       # + FastAPI gateway server
pip install multimind-sdk[all]           # rag, vector-stores, agents, memory, documents, finetune, compliance, gateway, mcp
# Framework adapters are separate: [langchain] [llamaindex] [crewai] [autogen]

Ollama users: no extra needed — multimind.models.ollama talks to a running Ollama instance over HTTP. Just pip install multimind-sdk and point at http://localhost:11434.

Features

Note: multimind.mcp is MultiMind's internal Model Composition Protocol — a workflow executor for chaining models. Anthropic's Model Context Protocol is supported separately via multimind.mcp_server (see docs/mcp-server.md).

Full status: docs/feature-status.md · Roadmap: ROADMAP.md

Examples

Snippets using await assume an async context — wrap them in asyncio.run(main()) as shown in the Quick Start. Full runnable versions live in examples/ and the cookbook.

Govern an app you already have — change one line

Start the compliance proxy, then point any OpenAI-compatible client (LangChain, LlamaIndex, the raw openai SDK, anything) at it:

multimind serve --port 8400 --upstream openai --block-on ssn,credit_card --budget 25.00 --audit-log audit.jsonl

from openai import OpenAI

# The ONLY change: base_url. Every call now gets PII redaction, budgets, and an audit trail.
client = OpenAI(base_url="http://localhost:8400/v1", api_key="unused-upstream-key-is-server-side")
client.chat.completions.create(model="gpt-4o-mini", messages=[{"role": "user", "content": "..."}])

Prefer to stay in code? Wrap your existing framework objects instead — see docs/integrations.md for LangChain, LlamaIndex, CrewAI, and OpenAI-SDK adapters.

Guard any model against PII leaks

from multimind import OpenAIModel
from multimind.compliance import guard

model = guard(
    OpenAIModel(model_name="gpt-4o-mini"),
    strategy="mask",                    # emails become [EMAIL], SSNs [SSN], ...
    block_on=("credit_card", "ssn"),    # refuse these outright
    audit_log="compliance_audit.jsonl", # types & counts only — never raw PII
)

response = await model.generate("Email jane.doe@corp.com about the invoice")
# The provider only ever saw: "Email [EMAIL] about the invoice"

Detects emails, phone numbers, SSNs, credit cards (Luhn-validated), IPs, IBANs, API keys (entropy-checked), and more — including across streaming chunk boundaries. Works with any model object that has generate/chat, so you can wrap non-MultiMind clients too. No extra dependencies. Runnable demo: examples/compliance/guarded_model.py

Multi-model chat

from multimind import OpenAIModel, ClaudeModel, GeminiModel, GroqModel

gpt = OpenAIModel(model_name="gpt-4o-mini")
claude = ClaudeModel(model_name="claude-3-5-sonnet-20241022")
gemini = GeminiModel(model_name="gemini-2.0-flash")
groq = GroqModel(model_name="llama-3.3-70b-versatile")

# Same interface, different providers
response = await gpt.generate("Hello!")
response = await claude.generate("Hello!")
response = await gemini.generate("Hello!")

MistralAIModel and DeepSeekModel work the same way.

Sync usage (no asyncio needed)

from multimind import OpenAIModel

model = OpenAIModel(model_name="gpt-4o-mini")
response = model.generate_sync("Explain quantum computing simply")

chat_sync and embeddings_sync are also available. Inside a running event loop, use the async methods instead.

Structured output

from pydantic import BaseModel
from multimind import OpenAIModel

class City(BaseModel):
    name: str
    population: int

model = OpenAIModel(model_name="gpt-4o-mini")
city = await model.generate("Largest city in France?", response_format=City)
print(city.name, city.population)  # a City instance, not a string

Works with OpenAIModel, ClaudeModel, GeminiModel, MistralAIModel, GroqModel, and DeepSeekModel.

RAG over your documents

from multimind.rag.fluent import RAGPipeline, RAGConfig
from multimind.vector_store.base import VectorStoreConfig, VectorStoreFactory
from multimind.core.router import Router

router = Router()  # register your providers with router.register_provider(...)

vector_store = VectorStoreFactory.create_store(
    "faiss",
    VectorStoreConfig.create_faiss_config(dimension=1536, metric="cosine"),
)

pipeline = RAGPipeline(router, RAGConfig(
    vector_store=vector_store,
    embedding_provider="openai",
    embedding_model="text-embedding-ada-002",
    generation_provider="openai",
    generation_model="gpt-4o-mini",
))

result = await (
    pipeline
    .load_documents(["Your documents here"])
    .query("What does this say?")
    .generate()
    .execute()
)
print(result.answer)

Full working example: examples/rag/fluent_rag_example.py

Agent with tools

from multimind import OpenAIModel
from multimind.agents import Agent
from multimind.agents.tools import CalculatorTool

agent = Agent(
    model=OpenAIModel(model_name="gpt-4o-mini"),
    tools=[CalculatorTool()],
)

# The task should mention the tool by name to route to it.
# Required parameters for the tool are passed as kwargs to agent.run().
response = await agent.run("Use the calculator", expression="42 * 17")
print(response)

More examples: examples/

Documentation

Hosted docs: docs.multimind.dev. The same pages live in docs/.

• Docs index — everything in one place
• Quickstart — guarded, cost-tracked model calls in 5 minutes
• Cookbook — task-oriented recipes (providers, structured output, budgets, hallucination checks, gateway, docker)
• Getting started without writing code — for analysts, compliance officers, and PMs
• Deployment Guide — docker pull ghcr.io/multimindlab/multimind-sdk:latest, docker compose, and a fully local stack
• Compliance Guide
• API Reference
• Architecture
• Contributing

Contributing

We welcome contributions! See CONTRIBUTING.md for details.

git clone https://github.com/multimindlab/multimind-sdk.git
cd multimind-sdk
pip install -e ".[dev]"
pytest

License

Apache 2.0 — see LICENSE.

References

Third-party places where MultiMind SDK is discussed, listed, or used as material. None of these is a customer deployment; they are linked so you can judge the project's footprint yourself.

• MultiMind architecture lessons in the DevMentor portfolio: notes on adapting the model routing, hybrid retrieval, memory, and workflow ideas without using the package directly.
• agents-shipgate benchmark: uses this repository's Claude Code settings as a cold-start benchmark case.
• Awesome-Agentic-Workflow: includes the README under its reflection and adaptation collection.
• agents-radar digest, 19 March 2026: lists MultiMind among trending AI projects.
• AINews, 3 July 2025: the LM Studio Discord section covers MultiMind's model conversion, fine-tuning, and inference introduction.
• Articles: Introducing MultiMind SDK and Ensuring compliance when fine-tuning on DEV Community; listings on Onegen and AIxplore. Older articles describe the 0.2 API; the current reference is docs.multimind.dev.

Using MultiMind in a product or project? Open a discussion and we will link it here.

Discord · Twitter · Support