Einbetten des MCP-Servers

Eine von txtai unterstützte Model Context Protocol (MCP)-Serverimplementierung, die über eine standardisierte Schnittstelle semantische Suche, Wissensgraphenfunktionen und KI-gesteuerte Textverarbeitung bietet.

Die Leistungsfähigkeit von txtai: All-in-One-Embeddings-Datenbank

Dieses Projekt nutzt txtai , eine All-in-One-Einbettungsdatenbank für RAG, die semantische Suche, Wissensgraphenkonstruktion und Sprachmodell-Workflows nutzt. txtai bietet mehrere wichtige Vorteile:

• Einheitliche Vektordatenbank : Kombiniert Vektorindizes, Graphnetzwerke und relationale Datenbanken auf einer einzigen Plattform

• Semantische Suche : Finden Sie Informationen basierend auf der Bedeutung, nicht nur auf Schlüsselwörtern

• Knowledge Graph-Integration : Erstellen und fragen Sie automatisch Knowledge Graphen aus Ihren Daten ab

• Tragbare Wissensdatenbanken : Speichern Sie ganze Wissensdatenbanken als komprimierte Archive (.tar.gz), die einfach geteilt und geladen werden können

• Erweiterbares Pipeline-System : Verarbeiten Sie Text, Dokumente, Audio, Bilder und Videos über eine einheitliche API

• Local-First-Architektur : Führen Sie alles lokal aus, ohne Daten an externe Dienste zu senden

Related MCP server: TxtAI MCP Server

Wie es funktioniert

Das Projekt enthält ein Tool zum Erstellen einer Wissensdatenbank und einen MCP-Server. Das Tool zum Erstellen einer Wissensdatenbank ist eine Befehlszeilenschnittstelle zum Erstellen und Verwalten von Wissensdatenbanken. Der MCP-Server bietet eine standardisierte Schnittstelle für den Zugriff auf die Wissensdatenbank.

Es ist nicht erforderlich, das Tool zum Erstellen einer Wissensdatenbank zu verwenden. Sie können jederzeit eine Wissensdatenbank über die Programmierschnittstelle von txtai erstellen, indem Sie ein Python-Skript schreiben oder sogar ein Jupyter-Notebook verwenden. Sofern die Wissensdatenbank mit txtai erstellt wurde, kann sie vom MCP-Server geladen werden. Noch besser: Die Wissensdatenbank kann ein Ordner im Dateisystem oder eine exportierte .tar.gz-Datei sein. Geben Sie sie einfach an den MCP-Server weiter, und er lädt sie.

1. Erstellen Sie eine Wissensdatenbank mit kb_builder

Das Modul kb_builder bietet eine Befehlszeilenschnittstelle zum Erstellen und Verwalten von Wissensdatenbanken:

• Verarbeiten Sie Dokumente aus verschiedenen Quellen (Dateien, Verzeichnisse, JSON)

• Text extrahieren und Einbettungen erstellen

• Wissensgraphen automatisch erstellen

• Exportieren portabler Wissensdatenbanken

Beachten Sie, dass die Funktionalität möglicherweise eingeschränkt ist und derzeit nur aus praktischen Gründen bereitgestellt wird.

2. Starten Sie den MCP-Server

Der MCP-Server bietet eine standardisierte Schnittstelle für den Zugriff auf die Wissensdatenbank:

• Semantische Suchfunktionen

• Abfrage und Visualisierung von Wissensgraphen

• Textverarbeitungs-Pipelines (Zusammenfassung, Extraktion usw.)

• Vollständige Konformität mit dem Model Context Protocol

Installation

Empfohlen: Verwenden von uv mit Python 3.10+

Für optimale Ergebnisse empfehlen wir die Verwendung von uv mit Python 3.10 oder neuer. Dies ermöglicht ein besseres Abhängigkeitsmanagement und gewährleistet konsistentes Verhalten.

# Install uv if you don't have it already
pip install -U uv

# Create a virtual environment with Python 3.10 or newer
uv venv --python=3.10  # or 3.11, 3.12, etc.

# Activate the virtual environment (bash/zsh)
source .venv/bin/activate
# For fish shell
# source .venv/bin/activate.fish

# Install from PyPI
uv pip install kb-mcp-server

Hinweis : Wir fixieren Transformers auf Version 4.49.0, um Veraltungswarnungen zu transformers.agents.tools zu vermeiden, die ab Version 4.50.0 erscheinen. Wenn Sie eine neuere Version von Transformers verwenden, werden diese Warnungen möglicherweise angezeigt, beeinträchtigen jedoch nicht die Funktionalität.

Verwenden von conda

# Create a new conda environment (optional)
conda create -n embedding-mcp python=3.10
conda activate embedding-mcp

# Install from PyPI
pip install kb-mcp-server

Aus der Quelle

# Create a new conda environment
conda create -n embedding-mcp python=3.10
conda activate embedding-mcp

# Clone the repository
git clone https://github.com/Geeksfino/kb-mcp-server.git.git
cd kb-mcp-server

# Install dependencies
pip install -e .

Verwenden von UV (schnellere Alternative)

# Install uv if not already installed
pip install uv

# Create a new virtual environment
uv venv
source .venv/bin/activate

# Option 1: Install from PyPI
uv pip install kb-mcp-server

# Option 2: Install from source (for development)
uv pip install -e .

Verwendung von uvx (keine Installation erforderlich)

Mit uvx können Sie Pakete direkt von PyPI ausführen, ohne sie zu installieren:

# Run the MCP server
uvx --from kb-mcp-server@0.3.0 kb-mcp-server --embeddings /path/to/knowledge_base

# Build a knowledge base
uvx --from kb-mcp-server@0.3.0 kb-build --input /path/to/documents --config config.yml

# Search a knowledge base
uvx --from kb-mcp-server@0.3.0 kb-search /path/to/knowledge_base "Your search query"

Befehlszeilenverwendung

Aufbau einer Wissensdatenbank

Sie können die von PyPI installierten Befehlszeilentools, das Python-Modul direkt oder die praktischen Shell-Skripte verwenden:

Verwenden der installierten PyPI-Befehle

# Build a knowledge base from documents
kb-build --input /path/to/documents --config config.yml

# Update an existing knowledge base with new documents
kb-build --input /path/to/new_documents --update

# Export a knowledge base for portability
kb-build --input /path/to/documents --export my_knowledge_base.tar.gz

# Search a knowledge base
kb-search /path/to/knowledge_base "What is machine learning?"

# Search with graph enhancement
kb-search /path/to/knowledge_base "What is machine learning?" --graph --limit 10

Verwendung von uvx (keine Installation erforderlich)

# Build a knowledge base from documents
uvx --from kb-mcp-server@0.3.0 kb-build --input /path/to/documents --config config.yml

# Update an existing knowledge base with new documents
uvx --from kb-mcp-server@0.3.0 kb-build --input /path/to/new_documents --update

# Export a knowledge base for portability
uvx --from kb-mcp-server@0.3.0 kb-build --input /path/to/documents --export my_knowledge_base.tar.gz

# Search a knowledge base
uvx --from kb-mcp-server@0.3.0 kb-search /path/to/knowledge_base "What is machine learning?"

# Search with graph enhancement
uvx --from kb-mcp-server@0.3.0 kb-search /path/to/knowledge_base "What is machine learning?" --graph --limit 10

Verwenden des Python-Moduls

# Build a knowledge base from documents
python -m kb_builder build --input /path/to/documents --config config.yml

# Update an existing knowledge base with new documents
python -m kb_builder build --input /path/to/new_documents --update

# Export a knowledge base for portability
python -m kb_builder build --input /path/to/documents --export my_knowledge_base.tar.gz

Verwenden der Convenience-Skripte

Das Repository enthält praktische Wrapper-Skripte, die das Erstellen und Durchsuchen von Wissensdatenbanken erleichtern:

# Build a knowledge base using a template configuration
./scripts/kb_build.sh /path/to/documents technical_docs

# Build using a custom configuration file
./scripts/kb_build.sh /path/to/documents /path/to/my_config.yml

# Update an existing knowledge base
./scripts/kb_build.sh /path/to/documents technical_docs --update

# Search a knowledge base
./scripts/kb_search.sh /path/to/knowledge_base "What is machine learning?"

# Search with graph enhancement
./scripts/kb_search.sh /path/to/knowledge_base "What is machine learning?" --graph

Führen Sie ./scripts/kb_build.sh --help oder ./scripts/kb_search.sh --help aus, um weitere Optionen zu erhalten.

Starten des MCP-Servers

Verwenden des PyPI-Installed-Befehls

# Start with a specific knowledge base folder
kb-mcp-server --embeddings /path/to/knowledge_base_folder

# Start with a given knowledge base archive
kb-mcp-server --embeddings /path/to/knowledge_base.tar.gz

Verwendung von uvx (keine Installation erforderlich)

# Start with a specific knowledge base folder
uvx kb-mcp-server@0.2.6 --embeddings /path/to/knowledge_base_folder

# Start with a given knowledge base archive
uvx kb-mcp-server@0.2.6 --embeddings /path/to/knowledge_base.tar.gz

Verwenden des Python-Moduls

# Start with a specific knowledge base folder
python -m txtai_mcp_server --embeddings /path/to/knowledge_base_folder

# Start with a given knowledge base archive
python -m txtai_mcp_server --embeddings /path/to/knowledge_base.tar.gz

MCP-Serverkonfiguration

Der MCP-Server wird mithilfe von Umgebungsvariablen oder Befehlszeilenargumenten konfiguriert, nicht mithilfe von YAML-Dateien. YAML-Dateien werden nur zum Konfigurieren von txtai-Komponenten beim Aufbau der Wissensdatenbank verwendet.

So konfigurieren Sie den MCP-Server:

# Start the server with command-line arguments
kb-mcp-server --embeddings /path/to/knowledge_base --host 0.0.0.0 --port 8000

# Or using uvx (no installation required)
uvx kb-mcp-server@0.2.6 --embeddings /path/to/knowledge_base --host 0.0.0.0 --port 8000

# Or using the Python module
python -m txtai_mcp_server --embeddings /path/to/knowledge_base --host 0.0.0.0 --port 8000

# Or use environment variables
export TXTAI_EMBEDDINGS=/path/to/knowledge_base
export MCP_SSE_HOST=0.0.0.0
export MCP_SSE_PORT=8000
python -m txtai_mcp_server

Allgemeine Konfigurationsoptionen:

• --embeddings : Pfad zur Wissensdatenbank (erforderlich)

• --host : Hostadresse, an die gebunden werden soll (Standard: localhost)

• --port : Port, auf dem gelauscht wird (Standard: 8000)

• --transport : Zu verwendendes Transportmittel, entweder „sse“ oder „stdio“ (Standard: stdio)

• --enable-causal-boost : Aktivieren Sie die Funktion „Causal Boost“ für eine verbesserte Relevanzbewertung

• --causal-config : Pfad zur benutzerdefinierten YAML-Konfigurationsdatei für kausalen Boost

Konfigurieren von LLM-Clients zur Verwendung des MCP-Servers

Um einen LLM-Client für die Verwendung des MCP-Servers zu konfigurieren, müssen Sie eine MCP-Konfigurationsdatei erstellen. Hier ist ein Beispiel mcp_config.json :

Direkte Verwendung des Servers

Wenn Sie eine virtuelle Python-Umgebung zur Installation des Servers verwenden, können Sie die folgende Konfiguration verwenden. Beachten Sie, dass ein MCP-Host wie Claude keine Verbindung zum Server herstellen kann, wenn Sie eine virtuelle Umgebung verwenden. Sie müssen den absoluten Pfad zur ausführbaren Python-Datei der virtuellen Umgebung verwenden, in der Sie beispielsweise „pip install“ oder „uv pip install“ ausgeführt haben.

{
  "mcpServers": {
    "kb-server": {
      "command": "/your/home/project/.venv/bin/kb-mcp-server",
      "args": [
        "--embeddings", 
        "/path/to/knowledge_base.tar.gz"
      ],
      "cwd": "/path/to/working/directory"
    }
  }
}

Verwenden des Systemstandard-Python

Wenn Sie das Standard-Python Ihres Systems verwenden, können Sie die folgende Konfiguration verwenden:

{
    "rag-server": {
      "command": "python3",
      "args": [
        "-m",
        "txtai_mcp_server",
        "--embeddings",
        "/path/to/knowledge_base.tar.gz",
        "--enable-causal-boost"
      ],
      "cwd": "/path/to/working/directory"
    }
}

Alternativ, wenn Sie uvx verwenden, vorausgesetzt, Sie haben uvx über „brew install uvx“ usw. in Ihrem System installiert, oder Sie haben uvx installiert und global zugänglich gemacht über:

# Create a symlink to /usr/local/bin (which is typically in the system PATH)
sudo ln -s /Users/cliang/.local/bin/uvx /usr/local/bin/uvx

Dadurch wird ein symbolischer Link von Ihrer benutzerspezifischen Installation zu einem systemweiten Speicherort erstellt. Für macOS-Anwendungen wie Claude Desktop können Sie den systemweiten Pfad ändern, indem Sie eine launchd-Konfigurationsdatei erstellen oder bearbeiten:

# Create a plist file to set environment variables for all GUI applications
sudo nano /Library/LaunchAgents/environment.plist

Fügen Sie diesen Inhalt hinzu:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>my.startup</string>
  <key>ProgramArguments</key>
  <array>
    <string>sh</string>
    <string>-c</string>
    <string>launchctl setenv PATH $PATH:/Users/cliang/.local/bin</string>
  </array>
  <key>RunAtLoad</key>
  <true/>
</dict>
</plist>

Dann laden Sie es:

sudo launchctl load -w /Library/LaunchAgents/environment.plist

Damit dies wirksam wird, müssen Sie Ihren Computer jedoch neu starten.

{
  "mcpServers": {
    "kb-server": {
      "command": "uvx",
      "args": [
        "kb-mcp-server@0.2.6",
        "--embeddings", "/path/to/knowledge_base",
        "--host", "localhost",
        "--port", "8000"
      ],
      "cwd": "/path/to/working/directory"
    }
  }
}

Platzieren Sie diese Konfigurationsdatei an einem für Ihren LLM-Client zugänglichen Ort und konfigurieren Sie ihn für die Verwendung. Die genauen Konfigurationsschritte hängen von Ihrem LLM-Client ab.

Erweiterte Wissensdatenbankkonfiguration

Zum Erstellen einer Wissensdatenbank mit txtai ist eine YAML-Konfigurationsdatei erforderlich, die verschiedene Aspekte des Einbettungsprozesses steuert. Diese Konfiguration wird vom Tool kb_builder verwendet, nicht vom MCP-Server selbst.

Möglicherweise müssen Segmentierungs-/Chunking-Strategien, Einbettungsmodelle und Bewertungsmethoden angepasst sowie die Graphenkonstruktion, das kausale Boosting, die Gewichte der Hybridsuche und mehr konfiguriert werden.

Glücklicherweise bietet txtai ein leistungsstarkes YAML-Konfigurationssystem, das keine Programmierung erfordert. Hier ist ein Beispiel für eine umfassende Konfiguration zum Aufbau einer Wissensdatenbank:

# Path to save/load embeddings index
path: ~/.txtai/embeddings
writable: true

# Content storage in SQLite
content:
  path: sqlite:///~/.txtai/content.db

# Embeddings configuration
embeddings:
  # Model settings
  path: sentence-transformers/nli-mpnet-base-v2
  backend: faiss
  gpu: true
  batch: 32
  normalize: true
  
  # Scoring settings
  scoring: hybrid
  hybridalpha: 0.75

# Pipeline configuration
pipeline:
  workers: 2
  queue: 100
  timeout: 300

# Question-answering pipeline
extractor:
  path: distilbert-base-cased-distilled-squad
  maxlength: 512
  minscore: 0.3

# Graph configuration
graph:
  backend: sqlite
  path: ~/.txtai/graph.db
  similarity: 0.75  # Threshold for creating graph connections
  limit: 10  # Maximum connections per node

Konfigurationsbeispiele

Das Verzeichnis src/kb_builder/configs enthält Konfigurationsvorlagen für verschiedene Anwendungsfälle und Speicher-Backends:

Speicher- und Backend-Konfigurationen

• memory.yml : In-Memory-Vektoren (am schnellsten für die Entwicklung, keine Persistenz)

• sqlite-faiss.yml : SQLite für Inhalte + FAISS für Vektoren (lokale dateibasierte Persistenz)

• postgres-pgvector.yml : PostgreSQL + pgvector (produktionsbereit mit vollständiger Persistenz)

Domänenspezifische Konfigurationen

• base.yml : Basiskonfigurationsvorlage

• code_repositories.yml : Optimiert für Code-Repositories

• data_science.yml : Konfiguriert für Data-Science-Dokumente

• general_knowledge.yml : Allgemeine Wissensdatenbank

• research_papers.yml : Optimiert für wissenschaftliche Arbeiten

• technical_docs.yml : Konfiguriert für technische Dokumentation

Diese können Sie als Ausgangspunkt für Ihre eigenen Konfigurationen verwenden:

python -m kb_builder build --input /path/to/documents --config src/kb_builder/configs/technical_docs.yml

# Or use a storage-specific configuration
python -m kb_builder build --input /path/to/documents --config src/kb_builder/configs/postgres-pgvector.yml

Erweiterte Funktionen

Funktionen des Knowledge Graph

Der MCP-Server nutzt die integrierte Graphenfunktionalität von txtai, um leistungsstarke Wissensgraphenfunktionen bereitzustellen:

• Automatische Graphenkonstruktion : Erstellen Sie automatisch Wissensgraphen aus Ihren Dokumenten

• Graph Traversal : Navigieren Sie durch verwandte Konzepte und Dokumente

• Pfadfindung : Entdecken Sie Verbindungen zwischen verschiedenen Informationen

• Community-Erkennung : Identifizieren Sie Cluster verwandter Informationen

Kausaler Verstärkungsmechanismus

Der MCP-Server verfügt über einen ausgeklügelten Mechanismus zur kausalen Verstärkung, der die Suchrelevanz durch Identifizierung und Priorisierung kausaler Beziehungen verbessert:

• Mustererkennung : Erkennt kausale Sprachmuster sowohl in Abfragen als auch in Dokumenten

• Mehrsprachige Unterstützung : Wendet automatisch geeignete Muster basierend auf der erkannten Abfragesprache an

• Konfigurierbare Boost-Multiplikatoren : Verschiedene Arten von kausalen Übereinstimmungen erhalten anpassbare Boost-Faktoren

• Verbesserte Relevanz : Ergebnisse, die kausale Zusammenhänge erklären, werden in den Suchergebnissen priorisiert

Dieser Mechanismus verbessert die Antworten auf „Warum“- und „Wie“-Fragen erheblich, indem er Inhalte bereitstellt, die die Zusammenhänge zwischen Konzepten erklären. Die Konfiguration des kausalen Boostings ist über YAML-Dateien hochgradig anpassbar und ermöglicht die Anpassung an verschiedene Domänen und Sprachen.

Lizenz

MIT-Lizenz – Einzelheiten finden Sie in der Datei „LICENSE“