Verwenden von SQL MCP Server mit lokalen Modellen

DER SQL Model Context Protocol (MCP)-Server funktioniert mit jedem MCP-kompatiblen Client, nicht nur mit cloudgehosteten KI-Diensten. Wenn Ihre Umgebung den Zugriff auf cloudgroße Sprachmodelle (LLM) einschränkt – üblich in der Gesundheitsversorgung, Verteidigung, Finanzen, Energie und Maritimen Industrie – können Sie ein lokales Modell verbinden, das über Ollama oder ähnliche Tools bedient wird. In diesem Handbuch werden Setup-, Feldmetadatenkonfigurations- und Eingabeaufforderungsmuster behandelt, die kleine lokale Modelle zuverlässig machen.

Voraussetzungen

• Die CLI von Data API Builder ist installiert und für mindestens eine Entität konfiguriert. Installieren Sie die CLI-.
• Ollama mit einem Modell, das Tool-Aufrufe unterstützt (z. B. qwen3:8b, llama3.1:8b).
• Python 3,10+ mit den Paketen mcp und ollama.
• Eine ausgeführte SQL Server Instanz mit Daten.

Schritt 1: Konfigurieren von Feldmetadaten

Feldmetadaten sind der wichtigste Konfigurationsschritt für die Genauigkeit des lokalen Modells. Ohne Feldnamen und Beschreibungen sehen Agents nur Entitätsnamen und erraten Spaltennamen falsch.

Fügen Sie Ihre Entität mit einer Beschreibung hinzu, und fügen Sie dann Feldbeschreibungen hinzu, die gültige Werte für eingeschränkte Spalten enthalten:

dab add ServerInventory \
  --source dbo.ServerInventory \
  --permissions "anonymous:read" \
  --description "SQL Server instance inventory with version, environment, and sizing data"

dab update ServerInventory \
  --fields.name InstanceName --fields.primary-key true \
  --fields.description "SQL Server instance name (e.g., YOURSERVER01)"

dab update ServerInventory \
  --fields.name Environment \
  --fields.description "Deployment environment. Valid values: Prod, Dev, Test, UAT"

Die vollständige CLI-Referenz und bewährte Methoden, einschließlich eingeschränkter Werte, Parameterbeschreibungen und Skriptmuster, finden Sie unter Hinzufügen von Beschreibungen zu Entitäten.

Schritt 2: Starten des SQL MCP-Servers

dab start

SQL MCP Server wartet standardmäßig auf http://localhost:5000/mcp über streambaren HTTP-Transport. Jeder Client, der das MCP-Protokoll implementiert, kann eine Verbindung mit diesem Endpunkt herstellen.

Schritt 3: Verbinden Des lokalen Modells

Erstellen Sie einen MCP-Client, der Ihr Ollama-Modell mit SQL MCP Server verbindet. Im folgenden Python Beispiel wird das MCP-Python SDK und das ollama-Paket verwendet.

Abhängigkeiten installieren

pip install mcp ollama

Minimaler Python-Gurt

import asyncio
import json
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client
import ollama

MCP_URL = "http://localhost:5000/mcp"
MODEL = "qwen3:8b"

async def get_schema(session: ClientSession) -> str:
    """Call describe_entities and format results for the system prompt."""
    result = await session.call_tool("describe_entities", arguments={})
    entities = json.loads(result.content[0].text)
    lines = []
    for entity in entities.get("entities", []):
        fields = ", ".join(
            f"{f['name']} ({f.get('description', 'no description')})"
            for f in entity.get("fields", [])
        )
        lines.append(f"- {entity['name']}: {entity.get('description', '')}")
        if fields:
            lines.append(f"  Fields: {fields}")
    return "\n".join(lines)

async def run(user_question: str):
    async with streamable_http_client(MCP_URL) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # Preinject schema into the system prompt
            schema_text = await get_schema(session)
            system_prompt = f"""You query a SQL database through MCP tools.

Available entities:
{schema_text}

Rules:
- Use the exact field names shown above.
- Answer count questions with the count only.
- Do not produce summaries unless asked.
- Do not invent example data. Only return data from tool responses.
- If no results, say "No results found" and stop.
"""
            # Get available tools for Ollama
            tools_result = await session.list_tools()
            ollama_tools = [
                {
                    "type": "function",
                    "function": {
                        "name": t.name,
                        "description": t.description or "",
                        "parameters": t.inputSchema,
                    },
                }
                for t in tools_result.tools
            ]

            messages = [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_question},
            ]

            # Chat loop: let the model call tools until it produces a final answer
            while True:
                response = ollama.chat(
                    model=MODEL, messages=messages, tools=ollama_tools
                )
                msg = response["message"]
                messages.append(msg)

                if not msg.get("tool_calls"):
                    print(msg["content"])
                    break

                for tc in msg["tool_calls"]:
                    result = await session.call_tool(
                        tc["function"]["name"],
                        arguments=tc["function"]["arguments"],
                    )
                    messages.append(
                        {
                            "role": "tool",
                            "content": result.content[0].text,
                        }
                    )

asyncio.run(run("How many SQL 2019 servers are in production?"))

Diese Testumgebung deckt den gesamten Ablauf ab: Vorab-Injektion des Schemas, Tool-Erkennung, mehrstufige Tool-Aufrufe und Extraktion der finalen Antwort. Passen Sie MODEL und MCP_URL an Ihre Umgebung an.

Schema beim Start vorab einfügen

Kleine lokale Modelle (unter 14B-Parametern) erzeugen zuverlässigere Toolaufrufe, wenn sich Schemametadaten in der Systemaufforderung befindet, bevor die Unterhaltung beginnt. Anstatt sich darauf zu verlassen, dass das Modell describe_entities während der Konversation selbst aufruft, rufen Sie es beim Start des Harness auf und schleusen Sie das Ergebnis ein.

Warum Vorinjektion wichtig ist

Im Beispiel "Gurtzeug" im vorherigen Abschnitt wird dieses Muster veranschaulicht. Die Funktion get_schema() ruft describe_entities beim Start einmal auf und formatiert das Ergebnis in den System-Prompt.

Einschränken von Modellantworten

Ein Modell kann einen richtigen Toolaufruf tätigen, die richtigen Daten abrufen und trotzdem eine falsche Antwort erzeugen. Ein Modell, das beispielsweise gefragt wird: „Wie viele Produktionsserver gibt es?“, könnte zwar korrekt 16 Zeilen abrufen, dann aber mit einer 40-zeiligen Management-Zusammenfassung antworten, die halluzinierte Beispiele statt der Zahl 16 enthält.

Fügen Sie Ihrer Systemaufforderung explizite negative Regeln hinzu:

Rules:
- Answer count questions with the count only.
- Do not produce summaries unless the user asks for one.
- Do not invent example data. Only return data from tool responses.
- If a tool returns no results, say "No results found" and stop.

Die Zuverlässigkeit beim Aufrufen von Tools und die Antwortdisziplin sind zwei verschiedene Probleme. DAB gewährleistet einen präzisen Datenabruf über die Werkzeugebene. Ihr Prompt-Framework steuert, wie das Modell Ergebnisse präsentiert.

Considerations

Verwandte Inhalte

• Hinzufügen von Beschreibungen zu Entitäten
• Datenbearbeitungstools
• Bereitstellen in physisch isolierten Umgebungen
• Authentifizierung konfigurieren
• Stdio-Transport