Skip to main content
Glama
Agent Context MCP Server

Agent Context MCP Server

Agent Context MCP Server

A portable, tool-agnostic memory and code structure graph for agentic AI coding tools (OpenCode, Antigravity, Claude Code, etc.).

🧠 The Problem

Agentic AI tools typically keep their memory locked inside a single session. When you run out of context tokens or switch to a different AI tool, you lose:

  • What you were currently working on (tasks, pending steps).

  • Why past technical decisions were made.

  • The structural architecture of the codebase.

Related MCP server: Memory MCP

🚀 The Solution

The Agent Context Server is an MCP (Model Context Protocol) server that tracks working context and code structure in a lightweight, local SQLite database (.agentctx/context.db). It provides a single, portable memory that follows the project rather than the tool.

You can start a task in one AI tool, hit a context limit, open a completely different AI tool, and resume exactly where you left off.

✨ Features

  • Working Context Engine: Tracks active tasks, decisions, progress logs, and open questions across sessions.

  • Code Structure Graph: Uses tree-sitter to parse and map Python, JavaScript, and TypeScript files, extracting classes, functions, and methods without sending your code to external APIs.

  • Incremental Indexing: Smart content-hashing ensures only modified files are re-indexed.

  • Project Export: Built-in tools to instantly zip and backup your agent's memory state.

  • Fully Local & Private: No LLM calls inside the server; all state is kept entirely locally via SQLite.

🛠️ Prerequisites

📦 Installation

  1. Clone this repository to your machine:

    git clone (replace with your own repo URL once you push this to GitHub)
    cd agent-context-mcp-server
  2. The project uses uv for dependency management. The required packages (mcp, tree-sitter, tree-sitter-python, tree-sitter-javascript, tree-sitter-typescript) will be automatically managed when you run the server.

⚙️ MCP Configuration

To use this server with your preferred agentic AI tool (like Google Antigravity, OpenCode, or Claude Code), add the following to your MCP configuration settings:

{
  "mcpServers": {
    "agent-context-server": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/agent-context-mcp-server",
        "run",
        "server.py"
      ]
    }
  }
}

Note: Replace /absolute/path/to/agent-context-mcp-server with the actual path where you cloned this repository. The server will dynamically create the .agentctx/ directory in whatever project folder your AI agent is currently working in.


🧰 Available Tools

Once connected, your AI agent will have access to the following tools:

Working Context

  • start_task(title): Creates a new working context task.

  • log_progress(task_id, entry, entry_type): Appends a progress log (step_done, error_hit, next_step, note).

  • log_decision(task_id, decision, reason, symbol_ref): Logs technical decisions and the reasoning behind them.

  • add_question(question) / resolve_question(question_id): Manages open questions.

  • resume(task_id?): Retrieves the full state of the active task to seamlessly pick up work.

  • list_tasks(status?): Lists active, done, blocked, or abandoned tasks.

Structure Graph

  • graph.index(path, languages?): Parses a file (.py, .js, .ts, .jsx, .tsx) and extracts structural symbols.

  • graph.get_symbol(name): Retrieves a specific symbol's file path and line numbers.

  • graph.trace_calls(symbol_name, direction): Traces inbound or outbound function calls within the same file.

  • graph.get_architecture(): Returns a high-level overview of the parsed codebase, including files, symbol counts, and root entry points.

Lifecycle

  • project.export(): Zips the entire .agentctx/ directory for safe backup and sharing.


📄 License

  • MIT License

Available Tools

12 tools
add_questionC

Adds an unresolved open question to the context.

Inputs: question (required). Returns: result

graph.get_architectureB

Returns a basic high-level overview of the parsed codebase, including files, symbol counts, and entry points.

Inputs: no named parameters. Returns: result

graph.get_symbolC

Retrieves a symbol's info, file, and line numbers from the database.

Inputs: name (required). Returns: result

graph.indexC

Parses a given file path and saves the extracted symbols to the symbols table.

Inputs: path (required), languages. Returns: result

graph.trace_callsB

Returns the inbound or outbound call chain for a given symbol. direction: 'inbound' or 'outbound'

Inputs: direction (required), symbol_name (required). Returns: result

list_tasksB

Lists tasks, optionally filtered by status (active, done, blocked, abandoned).

Inputs: status. Returns: result

log_decisionC

Logs a technical decision with its reason to the context.

Inputs: reason (required), task_id (required), decision (required), symbol_ref. Returns: result

log_progressB
Appends a progress log entry to the task.
Valid entry_type values: step_done, error_hit, next_step, note

Inputs: entry (required), task_id (required), entry_type (required). Returns: result

project.exportA

Creates a compressed zip backup of the entire .agentctx/ directory.

Inputs: no named parameters. Returns: result

resolve_questionB

Marks an open question as resolved.

Inputs: question_id (required). Returns: result

resumeA
Returns the full state of a task (or the most recent active one if not provided):
active task details, recent progress, decisions, and open questions.

Inputs: task_id. Returns: result

start_taskC

Creates a new working context task and returns the task ID.

Inputs: title (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 12 tools

    Disambiguation5/5

    Tools are clearly separated into graph analysis (graph.*) and context management (add_question, log_decision, etc.), each with distinct purposes. No overlap between tools.

    Naming Consistency4/5

    Uses a mix of plain snake_case (add_question, list_tasks) and dotted hierarchical names (graph.get_architecture, project.export). Consistent within subgroups but inconsistent across the whole set.

    Tool Count5/5

    12 tools cover the main functionalities of code graph analysis and task/context management without being excessive. Well-scoped for the server's domain.

    Completeness3/5

    Core operations are present but missing lifecycle actions: no update/delete for tasks, decisions, or questions. Graph tools lack search or listing capabilities.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides AI coding assistants with persistent project memory to retain architectural decisions, code patterns, and domain knowledge across sessions. It stores data locally in a SQLite database, allowing agents to remember, recall, and manage project-specific context using full-text search.
      3 npm
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      Provides persistent cross-session memory and full-text search for AI coding assistants, storing project context, decisions, and preferences while enabling searchable access to conversation history via local SQLite.
      8
      1
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Provides AI coding assistants with persistent memory storage using a local SQLite database. Enables tools to remember project details, notes, and relationships across sessions to maintain context and reduce repetitive explanations.
      17
      4
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI assistants to maintain persistent understanding of code projects across chat sessions via a SQLite brain that caches structural maps, summaries, and decisions. Provides tools for querying project structure, searching code, and recording insights to reduce token usage and avoid re-analysis.
      16
      6
      MIT