Sutra
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Sutra help me design a debate agent for analyzing climate policy"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Sutra
mcp-name: io.github.4rgon4ut/sutra
The MCP Context Engineering Engine
Sutra is a Model Context Protocol (MCP) server that transforms how LLMs handle reasoning, memory, and orchestration. It provides a "Standard Library" of cognitive tools (Thinking Models), memory structures (Cells), and multi-agent patterns (Organs).
Installation
Using uv (Recommended)
uv tool install context-engineering-mcpUsing pip
pip install context-engineering-mcpRelated MCP server: MCP Think Tank
Configuration
Select your agent below and copy-paste the config.
Add to claude_desktop_config.json:
{
"mcpServers": {
"sutra": {
"command": "uv",
"args": ["tool", "run", "context-engineering-mcp"]
}
}
}Run this in your terminal:
claude mcp add sutra uv tool run context-engineering-mcpRun aider with the mcp flag:
aider --mcp "uv tool run context-engineering-mcp"Or add to .aider.conf.yml:
mcp: ["uv tool run context-engineering-mcp"]Add to ~/.gemini/settings.json:
{
"mcpServers": {
"sutra": {
"command": "uv",
"args": ["tool", "run", "context-engineering-mcp"]
}
}
}In MCP settings, add a new server:
Name: Sutra
Type: command
Command:
uv tool run context-engineering-mcp
Add to your config (TOML):
[mcp_servers.sutra]
command = "uv"
args = ["tool", "run", "context-engineering-mcp"]Core Features (v0.1.0)
1. The Gateway (Router)
Sutra automatically analyzes your request to decide the best strategy:
YOLO Mode: For immediate tasks ("Fix this bug"), it routes to specific cognitive tools.
Constructor Mode: For system design ("Build a bot"), it routes to the Architect.
2. The Architect
Generates blueprints for custom agents, combining:
Thinking Models:
understand_question,verify_logic,backtracking,symbolic_abstract.Memory Cells:
key_value(State),windowed(Short-term),episodic(Long-term).Organs:
debate_council(Multi-perspective),research_synthesis(Deep Dive).
3. The Librarian
A manual discovery tool (get_technique_guide) that lets you or the agent browse the full catalog of Context Engineering techniques.
Development
Requirements: Python 3.10+, uv (optional but recommended).
Clone the repo:
git clone https://github.com/4rgon4ut/sutra.git cd sutraInstall dependencies:
uv sync --all-extras # OR pip install -e ".[dev]"Run tests:
pytest
License
MIT
Available Tools
12 toolsanalyze_task_complexityC
Analyzes a task to recommend the most efficient tool (The Router).
Args:
task_description: The user's prompt or task.
Inputs: task_description (required).
backtrackingA
Produce a recursive backtracking scaffold for error correction.
Args:
objective: Overall goal to satisfy.
failed_step: The step or subgoal that failed.
trace: Optional reasoning trace leading to the failure.
constraints: Guardrails or requirements to respect.
Returns:
Structured prompt that rewinds to last stable state, explores
alternatives, and proposes a patched plan.
Inputs: objective (required), failed_step (required), trace, constraints. Returns: result
design_context_architectureB
Architects a custom context system based on a high-level goal (The Architect).
Returns a blueprint of Sutra components (Molecules, Cells, Organs, Thinking Models).
Use this when the user wants to build a persistent agent or complex workflow
rather than solving a single immediate task.
Args:
goal: The user's objective (e.g., "Build a writing assistant that learns my style").
constraints: Optional limits (e.g., "Must be lightweight").
Inputs: goal (required), constraints.
get_cell_protocolA
Returns a cell protocol template describing memory behaviors.
Args:
name: Identifier of the cell protocol (key_value, windowed, episodic).
Inputs: name. Returns: result
get_molecular_templateA
Returns the Python function for creating molecular contexts (Module 02). Use this to programmatically construct few-shot prompts.
Inputs: no named parameters. Returns: result
get_organB
Returns an organ template for multi-agent orchestration (Layer 4).
Organs combine programs and cells into cohesive workflows for complex tasks
requiring multi-perspective analysis or collaborative reasoning.
Args:
name: Identifier of the organ ('debate_council' for multi-perspective debate).
Inputs: name. Returns: result
get_prompt_programB
Returns a functional pseudo-code prompt template (Module 07).
Args:
program_type: The type of program ('math', 'debate').
Inputs: program_type. Returns: result
get_protocol_shellC
Returns a Protocol Shell. Can return a specific pre-defined template or a blank shell.
Args:
name: The name of the protocol (e.g., 'reasoning.systematic') OR a custom name.
intent: (Optional) The intent if creating a custom shell.
Inputs: name, intent. Returns: result
get_technique_guideA
Returns a guide to available Context Engineering techniques (The Librarian).
Use this to discover the best tool for a given task.
Args:
category: Filter by 'reasoning', 'workflow', 'code', 'project', or 'all'.
Inputs: category. Returns: result
symbolic_abstractA
Convert a concrete expression into abstract variables for reasoning.
Args:
expression: The raw text or equation to abstract.
mapping_hint: Optional guidance for token-to-symbol mapping.
goal: Optional downstream task (e.g., simplify, prove, generalize).
Returns:
Structured prompt that maps tokens to symbols, restates the problem
abstractly, and provides a reversible mapping table.
Inputs: expression (required), mapping_hint, goal. Returns: result
understand_questionB
Produce a protocol shell to decompose a user question.
Args:
question: The raw user ask to unpack.
context: Optional background knowledge or situational frame.
constraints: Explicit limits or success criteria.
Returns:
A structured prompt guiding the model to restate intent, surface
constraints, and prepare clarifying questions before acting.
Inputs: question (required), context, constraints. Returns: result
verify_logicA
Generate a verification protocol for a reasoning trace.
Args:
claim: The headline answer or assertion to validate.
reasoning_trace: The supporting chain-of-thought or proof steps.
constraints: Optional guardrails (requirements, risk limits).
Returns:
Structured prompt that audits assumptions, inference steps, and
evidence, then proposes patches for any defects.
Inputs: claim (required), reasoning_trace (required), constraints. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 12 tools
Each tool has a clearly distinct purpose: analyzing complexity, backtracking, architecture design, retrieving various templates (cell protocol, molecular, organ, prompt program, protocol shell, technique guide), symbolic abstraction, question decomposition, and logic verification. No overlapping functionality.
Most tools follow a verb_noun pattern (e.g., analyze_task_complexity, get_cell_protocol). However, 'backtracking' is a gerund and 'symbolic_abstract' combines an adjective with a verb, deviating slightly from the prevailing pattern.
With 12 tools, the server is well-scoped for its domain of context engineering. Each tool earns its place, covering analysis, design, template retrieval, and verification without being overwhelming or sparse.
The tool set covers core workflows: analyzing tasks, designing architecture, retrieving building blocks, and verifying logic. A minor gap is the lack of tools for executing or instantiating the designed blueprints, but the provided surface is largely complete for planning and template access.
Maintenance
Related MCP Connectors
End-to-end agent-managed company brain. Docs, diagrams, plans, databases, agents, Knowledge Graph.
A living memory and world-building layer for your AI: cards, worlds, personas and agent dispatch.
The operating system for self-organised AI agent teams.
Persistent memory and knowledge management for AI agents with semantic search and 50+ tools.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceFacilitates enhanced interaction with large language models (LLMs) by providing intelligent context management, tool integration, and multi-provider AI model coordination for efficient AI-driven workflows.MIT
- AlicenseBqualityDmaintenanceProvides AI assistants with enhanced reasoning capabilities through structured thinking, persistent knowledge graph memory, and intelligent tool orchestration for complex problem-solving.2063MIT
- AlicenseBqualityDmaintenanceProvides 10 structured reasoning strategies (Chain of Thought, ReAct, Tree of Thoughts, etc.) for complex problem-solving with session persistence, branching, and tool integration capabilities.32 npm28MIT
- AlicenseBqualityDmaintenanceProvides AI systems with structured thinking frameworks and reasoning tools to maintain consistent problem-solving patterns across conversations. Enables multi-step reasoning, decision analysis, and systematic troubleshooting through invocable mental models.1543 npm20MIT