SQL MCP Server gebruiken met lokale modellen

Important

SQL Model Context Protocol (MCP) Server is beschikbaar in Data API Builder versie 1.7. Gebruik de preview-versie 2.0 voor de nieuwste mogelijkheden en oplossingen voor fouten.

SQL Model Context Protocol (MCP) Server werkt met elke MCP-compatibele client, niet alleen in de cloud gehoste AI-services. Als uw omgeving de toegang tot het grote taalmodel (LLM) van de cloud beperkt( gebruikelijk in gezondheidszorg, defensie, financiën, energie en maritieme industrieën), kunt u een lokaal model verbinden dat wordt geleverd via Ollama of vergelijkbare hulpprogramma's. In deze handleiding worden instellingen, configuratie van veldmetagegevens en promptpatronen beschreven die kleine lokale modellen betrouwbaar maken.

Prerequisites

Data API builder CLI geïnstalleerd en geconfigureerd met ten minste één entiteit. Installeer de CLI.
Ollama met een model dat ondersteuning biedt voor het aanroepen van hulpprogramma's (bijvoorbeeld qwen3:8b, llama3.1:8b).
Python 3.10+ met de pakketten mcp en ollama.
Een actief SQL Server exemplaar met gegevens.

Stap 1: veldmetagegevens configureren

Veldmetagegevens is de belangrijkste configuratiestap voor de nauwkeurigheid van het lokale model. Zonder veldnamen en beschrijvingen zien agents alleen entiteitsnamen en raden kolomnamen onjuist aan.

Warning

Als u deze stap overslaat, wordt een MCP-server geproduceerd die technisch werkt, maar functioneel onbruikbaar is door elk model dat toolreacties leest. Het model heeft geen informatie over uw kolommen.

Voeg uw entiteit toe met een beschrijving en voeg vervolgens veldbeschrijvingen toe die geldige waarden bevatten voor beperkte kolommen:

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"

Zie Beschrijvingen toevoegen aan entiteiten voor de volledige CLI-referentie en aanbevolen procedures, waaronder beperkte waarden, parameterbeschrijvingen en scriptpatronen.

Note

De dab update CLI behandelt komma's als scheidingstekens voor argumenten. Als uw beschrijving komma's bevat, bewerk dan in plaats daarvan dab-config.json rechtstreeks.

Stap 2: SQL MCP Server starten

dab start

SQL MCP Server luistert standaard op http://localhost:5000/mcp met behulp van streambaar HTTP-transport. Elke client die het MCP-protocol implementeert, kan verbinding maken met dit eindpunt.

Stap 3: Uw lokale model verbinden

Bouw een MCP-client die uw Ollama-model verbindt met SQL MCP Server. In het volgende Python voorbeeld wordt het MCP Python SDK en het ollama-pakket gebruikt.

Afhankelijkheden installeren

pip install mcp ollama

Minimale Python-testopstelling

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?"))

Dit framework ondersteunt de volledige cyclus: het vooraf injecteren van schema's, de detectie van beschikbare hulpprogramma's, het aanroepen van hulpprogramma's over meerdere beurten en de extractie van het uiteindelijke antwoord. Pas MODEL en MCP_URL aan voor uw omgeving.

Preinject-schema bij het opstarten

Kleine lokale modellen (onder 14B-parameters) produceren betrouwbaardere hulpprogramma-aanroepen wanneer schemametagegevens in de systeemprompt worden weergegeven voordat het gesprek begint. In plaats van erop te vertrouwen dat het model tijdens het gesprek zelf describe_entities aanroept, roept u dit aan bij het opstarten van de testharnas en injecteert u het resultaat.

Waarom preinjectie belangrijk is

Methode	Gedrag met kleine modellen
Dynamische ontdekking	Model moet eerst besluiten om eerst aan te roepen `describe_entities` , vervolgens resultaten te interpreteren en vervolgens het juiste hulpprogramma aan te roepen met de juiste veldnamen. Meerdere faalpunten.
Voorinjectie	Model ziet direct entiteitsnamen, veldnamen en beschrijvingen. Het juiste hulpprogramma roept de eerste poging aan.

In het harnasvoorbeeld in de vorige sectie ziet u dit patroon. De get_schema() functie roept describe_entities eenmaal aan bij het opstarten en formatteert het resultaat in de systeemprompt.

Tip

Grotere cloudmodellen (GPT-4o, Claude) ontdekken meestal een schema tijdens het gesprek zonder voorinjectie. Dit patroon is het waardevolst voor modellen onder 14B-parameters.

Antwoorden op beperkingsmodellen

Een model kan een juiste tool-aanroep maken, de juiste gegevens ophalen en nog steeds een onjuist antwoord produceren. Een model waaraan bijvoorbeeld de vraag 'hoeveel productieservers?' wordt gesteld, kan correct 16 rijen ophalen en daarna antwoorden met een managementsamenvatting van 40 regels met verzonnen voorbeelden in plaats van het getal 16.

Voeg expliciete negatieve regels toe aan uw systeemprompt:

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.

De nauwkeurigheid van het aanroepen van tools en antwoorddiscipline zijn verschillende problemen. DAB zorgt ervoor dat nauwkeurige gegevens worden opgehaald via de toollaag. Uw promptconfiguratie bepaalt hoe het model resultaten presenteert.

Considerations

Onderwerp	Bijzonderheden
Hardware	Aanroepen van hulpprogramma's werkt op bescheiden hardware. Een 8B-parametermodel op een Nvidia GPU (8 GB video RAM) levert nuttige resultaten op. Houd rekening met een latentie van tientallen seconden per vraag, wat geschikt is voor batchworkloads.
Batch versus interactief	Kleine modellen zijn geschikt voor batchverwerking (prestatierapporten, voorraadquery's) waarbij latentietolerantie hoger is.
Beschikbaarheid van hulpprogramma's	`aggregate_records` is alleen beschikbaar in versie 2.0 preview en hoger. Op versie 1.7.x dwingen count- en aggregatiequery's het model alle overeenkomende rijen te lezen. Bekijk de beschikbaarheid van hulpprogramma's per versie.
Vervoer	Lokale modellen verbinden via HTTP-streaming met `/mcp`. Het standaardinvoer-/uitvoertransport (stdio) is een alternatief voor configuraties met één proces.
Authentication	Gebruik `anonymous` machtigingen voor lokale ontwikkeling. Configureer voor productie authenticatie die geschikt is voor uw omgeving.

Feedback

Is deze pagina nuttig?

Last updated on 2026-05-20