agent_bootstrap
[DEPRECATED -- use agent_handshake instead] Generic agent onboarding. Returns default config for unknown agents.
LABSCO SUMMARY
The reference material and the record of what has already been tried sit behind the same two searches.
Both search modes exist on purpose: keyword search for terms you already know, semantic search for a question phrased as a question, and a stack filter on each so a FastAPI answer does not arrive for a React problem. episodic_store is what makes episodic_search worth anything later — it records the task type and whether the attempt succeeded, not just what happened. The coordination pool assumes you are not alone: pool_signal marks a topic claimed or blocked so a second instance can see it before starting. agent_bootstrap is deprecated and points at agent_handshake.
What it is
A knowledge and coordination layer for agents: a searchable document store, a vector-backed episodic memory, and a pool that other instances read to see what is already taken.
What you get
- Keyword search across the knowledge base, and semantic search over LanceDB vectors with Gemini embeddings, both narrowable with a stack filter such as python or fastapi.
- Documents fetched by name in four kinds — skills, protocols, EUREKA breakthroughs and truth patches — with the skills list filterable by name and by stack compatibility.
- Episodic memory: store a reflection tagged CODE, RESEARCH, DEBUG or REVIEW together with whether it succeeded, and later find similar past experiences by vector similarity.
- A coordination pool where an instance signals completed, blocked, claimed or signaling against a topic and the files it affects, with recent pool activity readable.
- Code files parsed into semantic chunks — functions, classes and methods — for retrieval.
- A YouTube URL queued at high, normal or low priority for transcription and insight extraction.
- Onboarding that takes your model, context window, platform, client, languages, frameworks and project goal and returns a configuration, plus live system, memory and hive status.
Requirements
Nothing — no account, no key. agent_handshake is the intended first call: it takes your model, context window, platform, languages and frameworks and hands back a configuration matched to them.
Setup effort
Follow the published steps — pip install midos-mcp
USE CASES
01
Getting the house answer on a technique rather than a general one
The documents are written for this system, so the search that finds them matters more than a web lookup would.
02
Recording what worked so the next attempt starts further along
A reflection is only worth storing if it says whether the attempt succeeded; that is what makes the later similarity search useful.
03
Keeping two instances off the same piece of work
Claims and blocks are announced rather than discovered, which is the difference between coordination and collision.
04
Preparing a source file so retrieval finds the right part of it
Whole-file retrieval returns too much context; splitting on function and class boundaries is what makes a hit precise.
05
Connecting with a configuration matched to your own model
Context window and platform change what is sensible to send; declaring them once produces defaults for the rest of the session.
18 tools
Counted once with only startup setup. Other versions, modes or optional credentials may expose a different list.
agent_handshake
Personalized agent onboarding. Declare your environment and get optimal config.
Call this FIRST when connecting to MidOS. Pass as much info as you know. Unknown fields can be left empty -- you'll get sensible defaults.
Args: model: Your model ID (e.g. 'claude-opus-4-6', 'gemini-2.5-pro', 'opus') context_window: Your context window in tokens (e.g. 200000). 0 = auto-detect from model. client: Your CLI/IDE (e.g. 'claude-code', 'cursor', 'windsurf', 'cline') languages: Comma-separated languages (e.g. 'python,typescript') frameworks: Comma-separated frameworks (e.g. 'fastapi,react') platform: Your OS (e.g. 'windows', 'linux', 'macos') project_goal: What you're working on (e.g. 'manga engine with SVG rendering')
chunk_code
Parse code file into semantic chunks (functions, classes, methods) for better RAG retrieval.
Args: file_path: Path to code file to chunk
episodic_search
Search episodic memory for similar past experiences using vector similarity.
Args: query: Search query describing the experience/task limit: Maximum results (default: 5)
episodic_store
Store a new episodic memory/reflection for future learning.
Args: task_type: Type of task: CODE, RESEARCH, DEBUG, REVIEW input_preview: Brief description of the input/context success: Whether the task was successful
get_eureka
Get a specific EUREKA breakthrough document.
Args: name: EUREKA name (e.g., 'EUREKA_CACHE_SEMANTICA' or 'ATOM_001')
get_protocol
Get a specific protocol document.
Args: name: Protocol name (e.g., 'PROTOCOL_NEURAL_LINK')
get_skill
Get a specific skill/capability document by name.
Args: name: Skill name (e.g., 'RAG_SYSTEMS_2026_SOTA')
get_truth
Get a specific truth patch document.
Args: name: Truth patch name (e.g., 'AGENT_MITIGATIONS_CONTEXT_OVERFLOW')
hive_status
Get current status of the Midos hive system.
list_skills
List all available skills/capabilities.
Args: filter: Optional filter for skill names stack: Optional stack filter, comma-separated (e.g. 'python,react'). Skills with matching compatibility.json are prioritized.
memory_stats
Get statistics about the Midos memory system (LanceDB chunks, cache status).
pool_signal
Signal an action to the multi-instance coordination pool.
Args: action: Action type: 'completed', 'blocked', 'claimed', 'signaling' topic: Topic/task name summary: Brief description of the action affects: Files/resources affected (optional)
pool_status
Get multi-instance coordination pool status and recent activity.
project_status
Live MidOS system status + quick-start guide for your agent.
Call this anytime to get:
- Real-time knowledge base stats (chunks, skills, EUREKA, truth patches)
- Vector store health
- Available MCP tools with usage examples
- Research queue (pending topics)
- Tips to get the most out of MidOS
This is your /status command. Use it to orient yourself and teach your agent how to leverage MidOS.
research_youtube
Queue a YouTube video for research. Midos will transcribe and extract insights.
Args: url: YouTube URL to research priority: Priority: 'high', 'normal', 'low'
search_knowledge
Search the Midos knowledge base for relevant information.
Args: query: Search query (keywords or topic) max_results: Maximum results to return (default: 5)
semantic_search
Semantic search using LanceDB vectors (Gemini embeddings). More intelligent than keyword search.
Args: query: Natural language query (e.g., 'how to implement RAG pipelines') top_k: Number of results (default: 5) stack: Optional stack filter, comma-separated (e.g. 'python,fastapi'). Results mentioning these are boosted.
BEFORE YOU INSTALL
What to know first
Tools you get
18 tools when we connected. The documentation lists 34 tools on the free Dev tier and 68 on Pro ($10 a month); an invalid or expired key silently falls back to Dev. The knowledge base is not in the pip package: clone MidOSresearch/midos and set MIDOS_ROOT to that folder, as in the install steps.
Requires
Python 3.10+
CONTEXT COST
Light Standing cost
Rated by the size of the 18 tool definitions that ride along on every turn, not by how many there are
INSTALLATION
Connect your client
Server setup
TERMINAL
pip install midos-mcpIf you installed via pip, auto-detect won't find the knowledge base. Clone the repo and point MIDOS_ROOT to it:
TERMINAL
git clone https://github.com/MidOSresearch/midos.git
export MIDOS_ROOT=<YOUR_MIDOS_ROOT>Check the setup — it shows the detected root and knowledge counts:
TERMINAL
midos-mcp healthMCP Clients
Claude Desktop, Claude Code
TERMINAL
midos-mcp config --generate claude<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
Cursor
CURSOR · TERMINAL
midos-mcp config --generate cursor<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
Cline
CLINE · TERMINAL
midos-mcp config --generate cline<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
Windsurf
WINDSURF · TERMINAL
midos-mcp config --generate windsurf<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
Continue
CONTINUE · TERMINAL
midos-mcp config --generate continue<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
Zed
ZED · TERMINAL
midos-mcp config --generate zed<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
OpenCode
OPENCODE · TERMINAL
midos-mcp config --generate opencode<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
Any MCP client — HTTP
ANY MCP CLIENT — HTTP · TERMINAL
midos-mcp config --generate http<YOUR_MIDOS_ROOT> is the full path of the midos folder you cloned (the one containing knowledge/ and modules/). An export in your terminal does not reach a server your MCP client launches, so check that the entry the config command generates carries MIDOS_ROOT; if it does not, add it to that entry's "env" section with the same full path.
