prolog-reasoner

SWI-Prolog als „Logik-Rechner“ für LLMs – verfügbar als MCP-Server und Python-Bibliothek.

LLMs sind exzellent in natürlicher Sprache, haben aber Schwierigkeiten mit formaler Logik. Prolog ist exzellent in logischem Schlussfolgern, kann aber keine natürliche Sprache verarbeiten. prolog-reasoner schließt diese Lücke, indem es die SWI-Prolog-Ausführung für LLMs über zwei komplementäre Schnittstellen zugänglich macht:

• MCP-Server – das verbundene LLM (z. B. Claude) schreibt Prolog-Code und führt ihn über den Server aus. Auf der Serverseite ist kein LLM-API-Schlüssel erforderlich.

• Python-Bibliothek – eine vollständige NL→Prolog-Pipeline mit Selbstkorrektur für Programme, die kein LLM in der Schleife haben. Erfordert einen OpenAI- oder Anthropic-API-Schlüssel.

Beide Schnittstellen nutzen denselben Prolog-Executor; die Bibliothek fügt einen LLM-basierten Übersetzer hinzu.

Funktionen

• MCP-Tool (execute_prolog): Führen Sie beliebigen SWI-Prolog-Code mit einer Abfrage aus

• CLP(FD)-Unterstützung: Constraint-Logikprogrammierung für Zeitplanung und Optimierung

• Negation-as-failure, Rekursion, alle Standard-SWI-Prolog-Funktionen

• Transparente Zwischenrepräsentation: Prolog vor der Ausführung prüfen/modifizieren

• Bibliotheksmodus: NL→Prolog-Übersetzung mit Selbstkorrekturschleife (OpenAI / Anthropic)

Anforderungen

• Python ≥ 3.10

• SWI-Prolog installiert und im PATH (≥ 9.0)

• API-Schlüssel für OpenAI oder Anthropic – nur für den Bibliotheksmodus, nicht für den MCP-Server

Installation

# MCP server only (no LLM dependencies)
pip install prolog-reasoner

# Library with OpenAI
pip install prolog-reasoner[openai]

# Library with Anthropic
pip install prolog-reasoner[anthropic]

# Both providers
pip install prolog-reasoner[all]

MCP-Server-Einrichtung

Der MCP-Server stellt ein einzelnes Tool bereit, execute_prolog, das vom verbundenen LLM geschriebenen Prolog-Code ausführt. Es ruft keine externe LLM-API auf, daher ist kein API-Schlüssel erforderlich.

Claude Desktop / Claude Code

{
  "mcpServers": {
    "prolog-reasoner": {
      "command": "uvx",
      "args": ["prolog-reasoner"]
    }
  }
}

Oder, falls prolog-reasoner direkt installiert ist:

{
  "mcpServers": {
    "prolog-reasoner": {
      "command": "prolog-reasoner"
    }
  }
}

Docker (SWI-Prolog enthalten)

Verwenden Sie Docker, wenn Sie SWI-Prolog nicht lokal installieren möchten:

docker build -f docker/Dockerfile -t prolog-reasoner .

{
  "mcpServers": {
    "prolog-reasoner": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "prolog-reasoner"]
    }
  }
}

Tool-Referenz

execute_prolog(prolog_code, query, max_results=100)

• prolog_code – Prolog-Fakten und -Regeln (String)

• query – auszuführende Prolog-Abfrage, z. B. "mortal(X)" (String)

• max_results – Begrenzung der Anzahl der zurückgegebenen Lösungen (Standard 100)

Gibt ein JSON-Objekt mit success, output, query, error und metadata (Ausführungszeit, Ergebnisanzahl, Flag für abgeschnittene Ergebnisse) zurück.

Bibliotheksnutzung

Die Bibliothek stellt PrologExecutor (nur Prolog, kein LLM) und PrologReasoner (NL→Prolog-Pipeline, benötigt einen LLM-API-Schlüssel) bereit.

Prolog direkt ausführen (kein LLM)

import asyncio
from prolog_reasoner.config import Settings
from prolog_reasoner.executor import PrologExecutor

async def main():
    settings = Settings()  # no API key needed
    executor = PrologExecutor(settings)
    result = await executor.execute(
        prolog_code="human(socrates). mortal(X) :- human(X).",
        query="mortal(X)",
    )
    print(result.output)  # mortal(socrates)

asyncio.run(main())

Vollständige NL→Prolog-Pipeline (erfordert LLM-API-Schlüssel)

import asyncio
from prolog_reasoner import PrologReasoner, TranslationRequest, ExecutionRequest
from prolog_reasoner.config import Settings
from prolog_reasoner.executor import PrologExecutor
from prolog_reasoner.translator import PrologTranslator
from prolog_reasoner.llm_client import LLMClient

async def main():
    settings = Settings(llm_api_key="sk-...")  # from env or explicit
    llm = LLMClient(
        provider=settings.llm_provider,
        api_key=settings.llm_api_key,
        model=settings.llm_model,
        timeout_seconds=settings.llm_timeout_seconds,
    )
    reasoner = PrologReasoner(
        translator=PrologTranslator(llm, settings),
        executor=PrologExecutor(settings),
    )
    translation = await reasoner.translate(
        TranslationRequest(query="Socrates is human. All humans are mortal. Is Socrates mortal?")
    )
    print(translation.prolog_code)
    result = await reasoner.execute(
        ExecutionRequest(prolog_code=translation.prolog_code, query=translation.suggested_query)
    )
    print(result.output)

asyncio.run(main())

Konfiguration

Alle Einstellungen erfolgen über Umgebungsvariablen (Präfix PROLOG_REASONER_):

Benchmark

benchmarks/ enthält 30 Logikprobleme aus 5 Kategorien (Deduktion, Transitivität, Constraint, Widerspruch, mehrstufig), um LLM-only-Schlussfolgerungen mit LLM+Prolog-Schlussfolgerungen zu vergleichen. Der Benchmark nutzt den Bibliotheks-Pfad (Übersetzer + Executor), da er den NL→Prolog-Schritt erfordert.

Ergebnisse

Gemessen auf anthropic/claude-sonnet-4-6, ein Durchlauf über 30 Probleme:

Aufschlüsselung nach Kategorien:

Die Lücke konzentriert sich auf Constraint (SEND+MORE, 6-Damen-Problem, Rucksackproblem, K4-Färbung, Einstein-Rätsel) und mehrstufige Probleme (Nim-Spieltheorie, 3-Personen-Ritter-und-Schurken, TSP-4, Zebra-Rätsel) – genau der Bereich, der kombinatorisch/suchintensiv ist und in dem symbolische Solver die Mustervervollständigung übertreffen. Bei rein deduktiven oder transitiven Fragen ist das LLM bereits stark, und Prolog fügt Latenz hinzu, ohne die Genauigkeit zu verbessern.

Alle 3 LLM+Prolog-Fehler waren Prolog-Ausführungsfehler aufgrund von falsch formatiertem, vom LLM generiertem Code (fehlende Prädikatdefinitionen, ungebundene CLP(FD)-Variablen) und keine logischen Fehler – diese können durch Prompt-Tuning behoben werden.

Selbst ausführen

docker run --rm -e PROLOG_REASONER_LLM_API_KEY=sk-... \
    prolog-reasoner-dev python benchmarks/run_benchmark.py

Die Ergebnisse werden unter benchmarks/results.json gespeichert.

Entwicklung

# Build dev image
docker build -f docker/Dockerfile -t prolog-reasoner-dev .

# Run tests (no API key needed — LLM calls are mocked)
docker run --rm prolog-reasoner-dev

# With coverage
docker run --rm prolog-reasoner-dev pytest tests/ -v --cov=prolog_reasoner

# Or via docker compose
docker compose -f docker/docker-compose.yml run --rm test

Lizenz

MIT