Skip to main content
Glama

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-mcp

Using pip

pip install context-engineering-mcp

Related 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-mcp

Run 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).

  1. Clone the repo:

    git clone https://github.com/4rgon4ut/sutra.git
    cd sutra
  2. Install dependencies:

    uv sync --all-extras
    # OR
    pip install -e ".[dev]"
  3. Run tests:

    pytest

License

MIT

Available Tools

12 tools
analyze_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

    A3.5/5.0

    Scored across 12 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers