agda-mcp-server

agda-mcp-server is a stateful Model Context Protocol server for interactive Agda proof development.

It keeps a long-running Agda process alive in --interaction-json mode so MCP clients can use Agda the way a human does in an editor: load a file, inspect goals, split on variables, refine holes, infer types, normalize expressions, search the local environment, and iterate on proofs without restarting Agda for every request.

What this server provides

• Persistent interactive Agda sessions.

• Goal-aware proof actions over MCP.

• Stateless batch type-checking when you only want a quick validation pass.

• Navigation and scope-inspection helpers for large Agda codebases.

• Literate Agda support — extract code blocks from all seven literate formats.

• Structured semantic outputs for every tool, alongside human-readable text.

• Agent-native session introspection (agda_session_snapshot, agda_goal_catalog, agda_tool_recommend).

• Bug-report and issue-update bundle generation with stable fingerprints.

• A small extension system for project-specific or domain-specific tools.

How it works

The server launches Agda in --interaction-json mode and communicates through Agda's IOTCM protocol over standard input and output.

In practice, the workflow is:

1. Load an Agda file with agda_load.

2. Agda assigns interaction point IDs to all open goals.

3. Use those goal IDs with proof-oriented tools such as agda_goal_type, agda_case_split, agda_refine, or agda_give.

4. Reload the file after applying source edits so Agda can refresh its goals.

This statefulness is the main difference between agda_load and the stateless agda_typecheck command.

Requirements

Before using the server, make sure you have:

• Node.js >= 24

• An Agda installation available as agda on your PATH, or

• A repo-local pinned runner at tooling/scripts/run-pinned-agda.sh

If both are available, the pinned runner is preferred.

Installation

From source

npm install
npm run build

This produces the distributable server in dist/.

Local CLI entry point

After building, the executable entry point is:

node dist/index.js

The published package also exposes the agda-mcp-server binary through the bin field in package.json.

Use --help or --version to inspect the installed binary without starting the MCP server:

agda-mcp-server --version   # prints the server version
agda-mcp-server --help      # prints usage and all environment variables

Quick start

Start the server on stdio with a project root:

AGDA_MCP_ROOT=/path/to/agda/project node dist/index.js

If AGDA_MCP_ROOT is omitted, the current working directory is used.

Examples

Example: load a file and inspect goals

1. agda_load file="Nat/Properties.agda"
  → reports load status and goal IDs

2. agda_session_status
  → shows the loaded file and active goals

3. agda_goal_type goalId=0
  → returns the local context and expected type for `?0`

Example: refine a proof hole

1. agda_goal_type goalId=0
  → inspect the goal before editing

2. agda_refine goalId=0 expr="suc"
  → apply a constructor or function

3. agda_metas
  → inspect any new subgoals created by the refinement

Example: check an expression before committing to it

1. agda_elaborate goalId=0 expr="map f xs"
  → see Agda's elaborated form

2. agda_infer goalId=0 expr="map f xs"
  → confirm the inferred type

3. agda_give goalId=0 expr="map f xs"
  → fill the goal once the expression looks correct

Example: stateless validation in CI or editor automation

agda_typecheck file="MyModule.agda"

Use this when you want errors and warnings without creating a persistent session.

Semantic outputs

Every tool returns:

• Human-readable text for existing MCP clients (in content[].text).

• Structured content with stable envelope fields (tool, ok, classification, summary, data, diagnostics, provenance, elapsedMs).

Every tool's data carries at least the rendered text plus a tool-specific structured payload — e.g. solutions / rawSolutions / written for agda_solve_*, parsed clauses for agda_case_split, goalType and context arrays for goal queries, success and output for backends, display-state snapshots for the toggle/show family, and so on. Agents should prefer the structured fields over scraping the markdown body.

Core session tools (agda_load, agda_load_no_metas, agda_typecheck) expose completeness fields — goalCount, invisibleGoalCount, hasHoles, isComplete, and a classification of ok-complete / ok-with-holes / type-error — derived from a merged source-hole + protocol-counts signal so explicit hole markers ({!!} / ?) inside abstract blocks cannot trick the load into a false ok-complete.

MCP client configuration

Claude Code

Add a server entry similar to this in your Claude Code settings:

{
  "mcpServers": {
    "agda": {
      "command": "node",
      "args": ["mcp/agda-mcp-server/dist/index.js"],
      "env": {
        "AGDA_MCP_ROOT": "."
      }
    }
  }
}

Other MCP clients

Any MCP client that can spawn a stdio server can run this package. Use the same pattern:

• command: node

• args: path to dist/index.js

• environment: set AGDA_MCP_ROOT to the Agda project root

Session model

This server is intentionally stateful.

• One shared Agda session is kept alive.

• The session tracks the currently loaded file.

• Goal IDs are meaningful only for the currently loaded file and current Agda state.

• If the file changes on disk, reload it with agda_load before continuing.

If you only want a quick compile check and do not need goals, use agda_typecheck instead of creating a session.

Write-back for proof actions

The proof-action tools (agda_give, agda_refine, agda_refine_exact, agda_intro, agda_auto, agda_case_split, agda_solve_one, agda_solve_all) persist their result to the source file by default and auto-reload, so the session and disk stay in sync without a separate edit step. Pass writeToFile: false on any of those calls for session-only behavior (old default).

agda_apply_edit(file, oldText, newText, occurrence?) is a sibling primitive for non-goal edits — adding imports, renaming symbols, fixing typos. It substitutes oldText with newText in the named file and reloads. oldText must match exactly once unless occurrence (1-based) is provided.

Both paths share the same safety guarantees:

• Agda source files only. agda_apply_edit refuses anything outside the .agda / .lagda[.md/.rst/.tex/.org/.typ] allowlist — it cannot be used to modify .git/config, package.json, shell scripts, or other non-Agda files inside the project root.

• Path containment. All edits resolve the target path through realpath and verify it stays inside the project root; a symlink that physically points outside the root is refused.

• Symlink race defense. Source reads use O_NOFOLLOW; if a symlink is planted at the canonical path after path resolution, the read fails with ELOOP instead of silently following it.

• File size cap. The edit pipeline refuses to read or write any Agda source file larger than 512 KiB (524288 bytes). This protects memory, scanner cost, and blast radius — it is a deliberate soft cap, not a protocol limit. If you have a legitimate Agda source file that trips this, treat it as a sign that the file should be split rather than as a bug to work around.

• Atomic writes. Edits go through a temp-file-rename so readers never observe a partially-written state. The temp filename mixes pid and randomUUID() and is created with O_EXCL so it cannot be pre-planted by a concurrent process.

• Staleness guard. If the loaded file has been modified on disk since the last agda_load, the edit is refused and the session is reloaded to match disk — writes never clobber external changes.

Tool reference

Protocol coverage

This repository now tracks full command-inventory parity with Agda's interactive IOTCM command constructors listed in Agda.Interaction.Base (verification date: 2026-03-24).

• The current protocol inventory lives in src/protocol/command-registry.ts.

• The protocol parity matrix lives in src/protocol/parity-matrix.ts.

• The inventory and parity tests enforce that every tracked upstream command has a parity row, but semantic parity is tracked separately from mere command mapping.

• Architecture still keeps a clean separation between transport, protocol decoding, and MCP presentation layers.

Use agda_protocol_parity for the current matrix, including known gaps.

At the current milestone, the server now exposes:

• agda_goal_type_context_infer for goal, context, and inferred-type queries

• agda_goal_type_context_check for goal, context, and checked-term queries

• agda_goal for exact goal-only display

• agda_context for exact context-only display

• agda_refine_exact for exact Cmd_refine

• agda_intro for exact Cmd_intro

• agda_solve_one for exact Cmd_solveOne

• agda_load_no_metas for strict loading without unresolved goals

• agda_abort and agda_exit for process control

• agda_show_version for the running Agda process version

• agda_load_highlighting_info, agda_token_highlighting, and agda_highlight for highlighting control

• agda_show_implicit_args / agda_toggle_implicit_args and agda_show_irrelevant_args / agda_toggle_irrelevant_args for display toggles

• agda_compile, agda_backend_top, and agda_backend_hole for backend interaction commands

• agda_tools_catalog for manifest-derived tool and schema introspection

• agda_session_snapshot for one-call agent session introspection with suggested actions

• agda_goal_catalog for one-call full proof-state inspection across all goals

• agda_tool_recommend for priority-ordered next-tool recommendations based on proof state

• agda_bug_report_bundle and agda_bug_report_update_bundle for structured bug intake

Session management

Display and highlighting

Backend commands

Reporting and agent introspection

Goal inspection and proof interaction

These tools require a file to be loaded first via agda_load.

Navigation and environment inspection

Typical interactive workflow

1. agda_load file="MyModule.agda"
     → Status: OK, 3 unsolved goals (?0, ?1, ?2)

2. agda_goal_type goalId=0
     → Context: (x : Nat), (p : x ≡ zero)
     → Goal: x + zero ≡ x

3. agda_auto goalId=0
     → No automatic solution found.

4. agda_elaborate goalId=0 expr="+-identityʳ x"
     → Elaborated: +-identityʳ x : x + zero ≡ x

5. agda_give goalId=0 expr="+-identityʳ x"
     → Goal solved.

6. Apply edits to the source file if needed.

7. agda_load file="MyModule.agda"
     → Reload to refresh remaining goals.

Stateless vs stateful operations

Use agda_typecheck when you want:

• a quick yes or no answer about whether a file checks,

• error and warning output only,

• no interactive goal information,

• no persistent Agda session.

Use agda_load when you want:

• stable goal IDs,

• interactive commands against holes,

• proof search, refinement, elaboration, and local type information,

• a persistent Agda subprocess.

Environment variables

Extension modules

The core server is intentionally generic and supports external extension modules.

For complete setup instructions and multiple extension examples, see:

• docs/extensions.md

• examples/extensions/README.md

Development

Scripts

Local development flow

npm install
npm run build
npm test
npm run verify

Tests

The test suite currently focuses on lightweight, deterministic behavior such as:

• response parsing,

• Agda command string escaping,

• Agda binary discovery,

• session cleanup behavior.

The tests intentionally avoid depending on a live Agda installation so they can run reliably in normal CI environments.

An integration scaffold is also available for environments where Agda is installed:

RUN_AGDA_INTEGRATION=1 npm run test:integration

Backend integration commands can be exercised with:

RUN_AGDA_BACKEND_INTEGRATION=1 AGDA_BACKEND_EXPR=GHC npm run test:integration

AGDA_BACKEND_EXPR accepts backend constructor expressions such as GHC, GHCNoMain, LaTeX, QuickLaTeX, or OtherBackend "Name".

Publishing

The package is configured for public npm publishing.

Before publishing:

1. Update the version in package.json.

2. Run npm run verify.

3. Publish with npm using your normal release process.

The prepublishOnly script runs verification automatically before publish.

Only the following files are published:

• dist/

• README.md

• LICENSE

Continuous integration

This repository includes a GitHub Actions workflow at .github/workflows/ci.yml that:

• installs dependencies with npm ci,

• runs on pushes and pull requests,

• verifies the package on Node.js 24.

Community and maintenance files

This repository also includes:

• CONTRIBUTING.md for contributor setup and workflow guidance

• SECURITY.md for vulnerability reporting guidance

• CHANGELOG.md for release history

• .github/ISSUE_TEMPLATE/config.yml and issue forms for structured reports

• .github/pull_request_template.md for consistent pull requests

• .nvmrc and the packageManager field in package.json for local toolchain alignment

Architecture overview

src/
  index.ts
    Bootstraps the MCP server, registers core tools, and loads extensions.

  agda-process.ts
    Public barrel for the Agda integration layer.

  agda/
    session.ts
      Owns the Agda subprocess, transport, buffering, and session state.
    batch.ts
      Stateless batch type-checking.
    goal-operations.ts
      Goal-centric interactive commands.
    expression-operations.ts
      Expression normalization and type inference.
    advanced-queries.ts
      Constraints, scope, elaboration, module inspection, and search.
    display-operations.ts
      Highlighting and display-toggle command delegates.
    backend-operations.ts
      Compile and backend payload command delegates.
    backend-expression.ts
      Backend expression validation and normalization.
    response-parsing.ts
      Helpers for extracting user-facing messages from Agda responses.
    types.ts
      Shared types for the Agda integration layer.

  protocol/
    command-registry.ts
      Upstream command inventory and parity metadata.
    responses/
      goal-display.ts
      proof-actions.ts
      process-controls.ts
      backend.ts
        Focused response decoders per command family.

  tools/
    session.ts
      MCP tool registration for loading and status operations.
    proof.ts
      MCP tool registration for goal-oriented proof actions.
    navigation.ts
      MCP tool registration for source and environment navigation.
    display.ts
      MCP tool registration for highlighting and display toggles.
    backend.ts
      MCP tool registration for compile and backend payload commands.

  session/
    session-state.ts
      High-level session phase derivation used to keep process lifecycle concerns explicit.

Protocol notes

The server communicates with Agda using the IOTCM protocol over --interaction-json mode.

At a high level:

• commands are written to Agda on stdin as IOTCM strings,

• Agda emits newline-delimited JSON responses on stdout,

• stderr output is captured for diagnostics,

• session completion is inferred from status and running-info messages.

Troubleshooting

agda cannot be found

Make sure either:

• agda is installed and on your PATH, or

• tooling/scripts/run-pinned-agda.sh exists in the repo root.

Goal IDs stop working

Goal IDs are tied to the current loaded file and the current Agda state. If the source changed or you applied a case split, reload the file with agda_load.

Top-level commands fail with "No file loaded"

Most interactive commands require an active loaded file because they need the Agda session context. Start with agda_load.

Proof search or elaboration returns unexpected output

Agda response formatting varies across commands. When in doubt, inspect the goal again with agda_goal_type and retry with a simpler expression.

License

This project is licensed under the MIT License. External extension modules may use different licenses.