Skip to main content
Glama
FOL Prover MCP Server

FOL Prover MCP Server

FOL Prover MCP Server

An MCP (Model Context Protocol) server for First-Order Logic theorem proving using Vampire, E, and Prover9.

Features

  • Multiple Provers: Support for Vampire, E (eprover), Prover9, and built-in simple prover

  • Built-in Prover: Simple resolution-based prover requires no external installation

  • FOL Parsing: Parse and validate first-order logic formulas with Unicode notation

  • Session Management: Build proofs incrementally with named sessions

  • TPTP Export: Convert problems to standard TPTP format

  • Automatic Fallback: Try multiple provers if one fails

Related MCP server: Pyke MCP Server

Installation

Prerequisites

The server includes a built-in simple prover that works without any external installation. For more complex proofs, install one of the following theorem provers:

Vampire (recommended):

# Linux (Ubuntu/Debian)
sudo apt-get install vampire

# macOS (with Homebrew)
brew install vampire

# Or download from: https://github.com/vprover/vampire

E Prover:

# Linux (Ubuntu/Debian)
sudo apt-get install eprover

# macOS
brew install eprover

# Or download from: https://wwwlehre.dhbw-stuttgart.de/~sschulz/E/E.html

Prover9:

# Download from: https://www.cs.unm.edu/~mccune/prover9/

Install the MCP Server

pip install folprover-mcp

Or install from source:

git clone https://github.com/folprover-mcp/folprover-mcp
cd folprover-mcp
pip install -e .

Configuration

Add to your MCP client configuration:

Claude Desktop

Add to ~/.config/claude/claude_desktop_config.json (Linux/macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "folprover": {
      "command": "folprover-mcp"
    }
  }
}

VS Code with Continue

Add to your Continue configuration:

{
  "mcpServers": {
    "folprover": {
      "command": "folprover-mcp"
    }
  }
}

Usage

FOL Notation

The server supports standard FOL notation with Unicode operators:

Symbol

Meaning

Example

∀

Universal quantifier

∀x P(x)

∃

Existential quantifier

∃x P(x)

∧

Conjunction (AND)

P(x) ∧ Q(x)

∨

Disjunction (OR)

P(x) ∨ Q(x)

→

Implication

P(x) → Q(x)

↔

Biconditional

P(x) ↔ Q(x)

¬

Negation

¬P(x)

⊕

Exclusive OR

P(x) ⊕ Q(x)

You can also use ASCII alternatives:

  • forall or all for ∀

  • exists for ∃

  • & or and for ∧

  • | or or for ∨

  • -> or implies for →

  • <-> or iff for ↔

  • ~ or not for ¬

Tools

prove

Execute a FOL proof directly:

{
  "premises": [
    "∀x (Human(x) → Mortal(x))",
    "Human(socrates)"
  ],
  "conclusion": "Mortal(socrates)",
  "prover": "vampire"
}

add_premise

Add a premise to the current session:

{
  "premise": "∀x (Human(x) → Mortal(x))"
}

set_conclusion

Set the conclusion to prove:

{
  "conclusion": "Mortal(socrates)"
}

prove_session

Prove using the current session's premises and conclusion:

{
  "prover": "vampire"
}

parse_formula

Parse and validate a FOL formula:

{
  "formula": "∀x (P(x) → Q(x))"
}

convert_to_tptp

Convert a problem to TPTP format:

{
  "premises": ["∀x (P(x) → Q(x))", "P(a)"],
  "conclusion": "Q(a)"
}

list_provers

List available theorem provers:

{}

Session Management

  • create_session: Create a new named session

  • list_sessions: List all active sessions

  • switch_session: Switch to a different session

  • get_session: Get current session state

  • clear_session: Clear all premises and conclusion

  • remove_premise: Remove a premise by index

Examples

Example 1: Classic Syllogism

Premises:

  1. All humans are mortal: ∀x (Human(x) → Mortal(x))

  2. Socrates is human: Human(socrates)

Conclusion: Socrates is mortal: Mortal(socrates)

Result: Theorem (True)

Example 2: Set Theory

Premises:

  1. If x is a subset of y and y is a subset of z, then x is a subset of z: ∀x ∀y ∀z ((Subset(x,y) ∧ Subset(y,z)) → Subset(x,z))

  2. A is a subset of B: Subset(a, b)

  3. B is a subset of C: Subset(b, c)

Conclusion: A is a subset of C: Subset(a, c)

Result: Theorem (True)

Example 3: With Counter-model

Premises:

  1. Some birds can fly: ∃x (Bird(x) ∧ CanFly(x))

Conclusion: All birds can fly: ∀x (Bird(x) → CanFly(x))

Result: Not a theorem (False - there's a counter-model where some bird can't fly)

Architecture

folprover-mcp/
├── src/folprover_mcp/
│   ├── __init__.py
│   ├── server.py          # MCP server implementation
│   ├── provers.py         # Prover interfaces (Vampire, E, Prover9, Simple)
│   ├── simple_prover.py   # Built-in resolution prover
│   ├── fol_parser.py      # FOL formula parser
│   └── tptp_converter.py  # TPTP format converter
├── tests/                 # Test suite
├── examples/              # Example proof problems
├── pyproject.toml
└── README.md

References

License

MIT License

Available Tools

13 tools
add_premiseA

Add a premise (axiom) to the current session for incremental proof building.

Inputs: premise (required), session.

clear_sessionA

Clear all premises and conclusion from a session.

Inputs: session.

convert_to_tptpC

Convert a FOL problem to TPTP format (standard format for theorem provers).

Inputs: premises (required), conclusion (required).

create_sessionB

Create a new named session for proof building.

Inputs: name (required).

get_sessionA

Get the current state of a session including all premises and conclusion.

Inputs: session.

list_proversA

List available theorem provers and their status.

Inputs: no named parameters.

list_sessionsA

List all active sessions.

Inputs: no named parameters.

parse_formulaA

Parse and validate a FOL formula. Returns information about variables, constants, predicates, and whether the formula is syntactically valid.

Inputs: formula (required).

proveA

Execute a FOL proof. Attempts to prove the conclusion from the given premises using the specified theorem prover (vampire, eprover, or prover9).

Inputs: premises (required), conclusion (required), prover, timeout.

prove_sessionB

Execute a proof using the current session's premises and conclusion.

Inputs: prover, session.

remove_premiseB

Remove a premise by index from the current session.

Inputs: index (required), session.

set_conclusionC

Set the conclusion (goal) to prove in the current session.

Inputs: conclusion (required), session.

switch_sessionB

Switch to a different session.

Inputs: name (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 13 tools

    Disambiguation5/5

    Each tool has a clear, distinct purpose. There is no overlap between adding/removing premises, setting conclusions, managing sessions, parsing formulas, or executing proofs. The two prove tools are differentiated by whether they use session state or direct inputs.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case, such as add_premise, clear_session, list_provers, and set_conclusion. The verbs are descriptive and uniform.

    Tool Count5/5

    With 13 tools, the surface is well-scoped for a FOL prover server. It covers session management, formula parsing, multiple theorem provers, and TPTP conversion without excess.

    Completeness4/5

    The tool set covers the full proof workflow: create session, add premises, set conclusion, parse formulas, run proofs, and manage sessions. Minor gaps exist, such as no direct 'update premise' tool, but removing and re-adding works around this.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP-Logic is a server that provides AI systems with automated reasoning capabilities, enabling logical theorem proving and model verification using Prover9/Mace4 through a clean MCP interface.
      47
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server for the Pyke logic programming engine that enables LLMs to perform logical reasoning using knowledge bases with facts, rules, and queries. It supports session management, forward chaining inference, and bulk loading of programs in Logic-LLM format.
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that provides formal reasoning and argument validation tools for AI agents based on established computational argumentation theories. It enables structured argument analysis, defeasible reasoning, and dialogue management using frameworks like Dung, Toulmin, and Walton's schemes.
      -