Ansluta AI-agenter till Fabric API för GraphQL med en lokal MCP-server (Model Context Protocol)

Tänk dig att fråga GitHub Copilot "Visa mig all försäljning från förra kvartalet" och låta det automatiskt fråga ditt infrastrukturlager, förstå schemat och returnera resultat – allt utan att skriva en enda rad GraphQL. Den här handledningen visar hur du kan göra detta möjligt.

I den här självstudien skapar du en lokal GraphQL MCP-server som fungerar som en brygga mellan AI-agenter och dina Microsoft Fabric-data. I slutet har du en fungerande utvecklingsserver som gör det möjligt för AI-assistenter som GitHub Copilot, Claude och andra AI-agenter att naturligt köra frågor mot dina Infrastrukturdata med hjälp av konversationsspråk.

Vad du ska göra:

Konfigurera autentisering så att GraphQL MCP-servern kan komma åt Fabric på ett säkert sätt
Aktivera schema-introspektion så att AI-agenter kan identifiera din datastruktur automatiskt
Distribuera en lokal GraphQL MCP-server som översätter naturligt språk till GraphQL-frågor
Anslut GitHub Copilot eller andra AI-verktyg för att göra förfrågningar på dina data i en konversation.

Vad är MCP (Model Context Protocol)?

Model Context Protocol (MCP) är en standard för att ansluta AI-assistenter till de system där data finns, inklusive innehållsdatabaser, affärsverktyg och utvecklingsmiljöer. Syftet är att hjälpa gränsmodeller att ge bättre och mer relevanta svar. Tänk på MCP som en USB-C port för AI-program. Precis som USB-C ger ett standardiserat sätt att ansluta dina enheter till olika kringutrustningar och tillbehör, ger MCP ett standardiserat sätt att ansluta AI-modeller till externa datakällor och verktyg.

Stora AI-plattformar som OpenAI, Microsoft Copilot Studio och Microsoft Foundry har infört MCP som standard för att integrera AI-agenter med externa system. Detta gör MCP till ett idealiskt val för att ansluta AI-agenter till dina Microsoft Fabric-data.

Varför GraphQL är idealiskt för MCP

GraphQL passar bra för MCP-integreringar eftersom:

Schema-introspektion: AI-agenter kan automatiskt identifiera tillgängliga datastrukturer och relationer direkt från GraphQL-schemat
Flexibla frågor: Agenter kan begära exakt de data de behöver i en enda begäran
Typsäkerhet: Stark inmatning hjälper AI-agenter att förstå dataformat och begränsningar
Effektiv datahämtning: Minskar överhämtning och underhämtning av data

Microsoft Fabrics API för GraphQL gör det enkelt att exponera dina Fabric lakehouses, dataarkiv och databaser för AI-agenter via ett standardiserat GraphQL-gränssnitt. API för GraphQL har redan kraftfulla frågefunktioner, men det kanske inte är så enkelt att konfigurera en anslutning för AI-agenter.

Med en enkel lokal GraphQL MCP-server kan utvecklare använda AI-agenter för att identifiera sin infrastrukturdatastruktur, förstå vad som är tillgängligt och köra frågor mot den med hjälp av naturligt språk – allt via det standardiserade MCP-gränssnittet. Bekvämt nog behöver du inte definiera ett separat MCP-verktyg på servern för varje GraphQL-typ, fråga eller mutation. GraphQL MCP-servern introspekterar GraphQL-schemat, vilket möjliggör för AI-agenter att förstå alla tillgängliga typer och åtgärder från början.

Förutsättningar

Innan du påbörjar den här självstudien kontrollerar du att du har:

En Microsoft Fabric-arbetsyta med lämpliga behörigheter. En administratörsroll för arbetsytan krävs för att konfigurera tjänstens huvudnamn och aktivera introspektion.
Ett API för GraphQL-objekt som skapats och konfigurerats. Se Skapa och lägga till data i ett API för GraphQL eller Skapa GraphQL-API från din SQL-databas i Fabric-portalen.
Node.js installerat på utvecklingsdatorn (inklusive npm)
Visual Studio Code installerat på utvecklingsdatorn

Anmärkning

Är du inte administratör? Vissa steg i den här självstudien kräver administratörsbehörigheter. Om du inte är administratör kan du fortfarande slutföra det mesta av självstudien genom att be administratören att hjälpa till med specifika uppgifter. Varje steg som kräver administratörsbehörigheter är tydligt markerat.

Steg 1: Konfigurera åtkomst till tjänstens huvudkonto

Vad du gör: Konfigurera icke-interaktiva autentiseringsuppgifter så att GraphQL MCP-servern kan komma åt Infrastruktur utan att kräva att en användare loggar in varje gång.

Varför detta är viktigt: GraphQL MCP-servern körs som en bakgrundstjänst som AI-agenter anropar automatiskt. Den behöver en egen identitet (ett huvudnamn för tjänsten) med autentiseringsuppgifter för att autentisera till Fabric för ditt program, inte för en specifik användares räkning.

Följ den kompletta guiden på Använd tjänstprincipaler med Fabric API för GraphQL för att:

Skapa en Azure App Registration (alla användare med behörighet att skapa appregistreringar i Microsoft Entra-ID)
Lägg till en klienthemlighet under Certifikat och hemligheter (alla användare)
Aktivera tjänsteprincipaler i klientinställningarna (kräver Fabric-klientadministratör)
Bevilja behörigheter till GraphQL-API:et och arbetsytan (kräver rollen arbetsyteadministratör eller deltagare)

Tips/Råd

Är du inte administratör? Du kan slutföra de två första objekten själv. För inställningen av klientorganisationen, be din Fabric-klientadministratör att aktivera "Tjänstens huvudmän kan använda Fabric-API:er" under Administratörsportalen>Klientinställningar>Utvecklarinställningar. För att få behörighet till arbetsytan, be din administratör för arbetsytan att ge ditt tjänstehuvudkonto tillgång till arbetsytan eller en specifik GraphQL-API.

När du har slutfört installationen samlar du in dessa tre värden för GraphQL MCP-serverkonfigurationen:

Klientorganisations-ID: Finns i Microsoft Entra-ID under Översikt>klientorganisations-ID
Klient-ID: Finns i din appregistrering under Översikt>Applikations-ID (klient)
Klienthemlighet: Det hemliga värdet som visas när du skapar en ny klienthemlighet (kopiera omedelbart – det visas bara en gång)

Steg 2: Aktivera GraphQL-introspektion (kräver arbetsyteadministratör)

Vad du gör: Genom att aktivera introspektion kan GraphQL MCP-servern fråga GraphQL-API:et "Vilka data har du?" och få en fullständig beskrivning av alla tillgängliga typer, fält och relationer.

Varför detta är viktigt: Detta är den "magi" som gör frågor på naturligt språk möjliga. När du frågar Copilot "Visa mig kunder" använder AI-agenten först introspektion för att upptäcka att det finns en customers typ, vilka fält den har och hur den efterfrågas. Utan introspektion skulle du behöva dokumentera hela schemat för AI:n manuellt.

Viktigt!

Introspektion måste vara aktiverat för att GraphQL MCP-servern ska fungera. Detta är inaktiverat som standard i Fabric av säkerhetsskäl. Endast arbetsyteadministratörer kan aktivera introspektion. Om du inte är administratör ber du arbetsyteadministratören att slutföra det här steget.

Följ den fullständiga guiden i Microsoft Fabric API för GraphQL Introspection och Schema Export för att:

Aktivera introspektion i DINA API-inställningar
Förstå hur introspektionsfrågor fungerar
Läs mer om alternativ för schemaexport

När introspektion har aktiverats kan GraphQL MCP-servern fråga din schemastruktur och göra den tillgänglig för AI-agenter.

Steg 3: Konfigurera GraphQL MCP-servern

Vad du gör: Installera och konfigurera en lokal Node.js server som implementerar Model Context Protocol. Den här servern fungerar som en översättare mellan AI-agenter och ditt Fabric GraphQL-API.

Varför detta är viktigt: MCP-servern tillhandahåller ett standardiserat gränssnitt som AI-agenter förstår. När en AI-agent ansluter kan den identifiera vilka verktyg som är tillgängliga (introspektion och frågor), anropa dessa verktyg och ta emot svar – allt utan att du skriver anpassad integreringskod för varje AI-plattform.

Nu när du har aktiverat autentiseringsuppgifter (steg 1) och introspektion (steg 2) är du redo att konfigurera servern så att den använder dem.

Klona exempellagringsplatsen

git clone https://github.com/microsoft/fabric-samples.git
cd fabric-samples/docs-samples/data-engineering/GraphQL/MCP

Installera beroenden

npm install

Konfigurera miljövariabler

Skapa en .env fil i projektroten med din konfiguration:

MICROSOFT_FABRIC_API_URL=https://your-fabric-endpoint/graphql
MICROSOFT_FABRIC_TENANT_ID=your_tenant_id_here
MICROSOFT_FABRIC_CLIENT_ID=your_client_id_here
MICROSOFT_FABRIC_CLIENT_SECRET=your_client_secret_here
SCOPE=https://api.fabric.microsoft.com/.default

Ersätt platshållarvärdena med:

MICROSOFT_FABRIC_API_URL: Din GraphQL-slutpunkt från Fabric-portalen
MICROSOFT_FABRIC_TENANT_ID: Ditt Azure-klient-ID
MICROSOFT_FABRIC_CLIENT_ID: Klient-ID för appregistrering
MICROSOFT_FABRIC_CLIENT_SECRET: Din klienthemlighet för appregistrering

Starta GraphQL MCP-servern

node FabricGraphQL_MCP.js

Servern startar http://localhost:3000 och displayen visar:

Microsoft Fabric GraphQL MCP server listening on port 3000
API URL: https://your-fabric-endpoint/graphql
Scope: https://api.fabric.microsoft.com/.default

Tillgängliga MCP-verktyg

GraphQL MCP-servern innehåller två huvudverktyg:

`introspect-schema`

Syfte: Hämtar det fullständiga GraphQL-schemat
Parametrar: Ingen
Användning: Måste anropas först innan du gör frågor

`query-graphql`

Syfte: Kör GraphQL-frågor mot dina Infrastrukturdata
Parametrar:
- query (krävs): GraphQL-frågesträngen
- variables (valfritt): GraphQL-variabelobjekt
Användning: För alla åtgärder för datahämtning och manipulering

Förstå arbetsflödet

Det typiska GraphQL MCP-arbetsflödet följer det här mönstret:

Schemaidentifiering: AI-agenten introspect-schema måste först anropa verktyget för att förstå schemat och tillgängliga data
Frågeplanering: Agenten analyserar din begäran om naturligt språk och GraphQL-schemat
Frågegenerering: Agenten skapar lämpliga GraphQL-frågor
Körning: Agenten query-graphql anropar verktyget med de genererade frågorna
Svarsbearbetning: Agenten formaterar och visar resultatet

Steg 4: Testa GraphQL MCP-servern

Vad du gör: Kontrollera att MCP-servern kan autentisera till Fabric, hämta schemat och köra frågor – innan DU ansluter AI-agenter.

Varför detta är viktigt: Genom att testa manuellt ser du till att allt är korrekt konfigurerat. Om dessa tester godkänns vet du att AI-agenterna kan ansluta i steg 5.

Verifiera serverns hälsotillstånd

Kontrollera först att servern körs och kan autentisera till Fabric.

Använda PowerShell:

Invoke-RestMethod -Uri "http://localhost:3000/health" -Method Get

Använda cURL:

curl http://localhost:3000/health

Du bör få ett svar som anger att servern körs, ungefär som:

{"status":"healthy","server":"Microsoft Fabric GraphQL MCP Server","hasToken":true,"tokenExpiry":"2025-06-30T23:11:36.339Z"}

Testa schema-introspektion

Kontrollera sedan att servern kan hämta GraphQL-schemat via introspektion. Detta anropar introspect-schema MCP-verktyget.

Använda PowerShell:

$headers = @{
    "Content-Type" = "application/json"
    "Accept" = "application/json, text/event-stream"
}

$body = @{
    jsonrpc = "2.0"
    id = 1
    method = "tools/call"
    params = @{
        name = "introspect-schema"
        arguments = @{}
    }
} | ConvertTo-Json -Depth 3

Invoke-RestMethod -Uri "http://localhost:3000/mcp" -Method Post -Body $body -Headers $headers

Använda cURL:

curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "introspect-schema",
      "arguments": {}
    }
  }'

Detta bör returnera graphQL-schemadefinitionen.

Testa en GraphQL-fråga

Testa slutligen att köra en faktisk GraphQL-fråga via MCP-servern. Det här exemplet frågar efter alla typnamn i schemat med hjälp av query-graphql MCP-verktyget.

Använda PowerShell:

$headers = @{
    "Content-Type" = "application/json"
    "Accept" = "application/json, text/event-stream"
}

$body = @{
    jsonrpc = "2.0"
    id = 2
    method = "tools/call"
    params = @{
        name = "query-graphql"
        arguments = @{
            query = "query { __schema { types { name } } }"
        }
    }
} | ConvertTo-Json -Depth 4

Invoke-RestMethod -Uri "http://localhost:3000/mcp" -Method Post -Body $body -Headers $headers

Använda cURL:

curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "query-graphql",
      "arguments": {
        "query": "query { __schema { types { name } } }"
      }
    }
  }'

Då returneras en lista över alla typer i GraphQL-schemat.

Steg 5: Ansluta AI-agenter

Vad du gör: Konfigurera AI-verktyg för att använda din lokala MCP-server som datakälla.

Varför detta är viktigt: Det är här allt samlas. När ai-agenterna är anslutna kan de identifiera ditt Fabric-schema genom introspektion och generera GraphQL-frågor baserat på begäranden om naturligt språk. AI:n hanterar frågesyntaxen – du ställer bara frågor på vanlig engelska.

GitHub Copilot i Visual Studio Code

Installera GitHub Copilot-tillägget i VS Code

Konfigurera GraphQL MCP-servern i Dina Copilot-inställningar:

{
  "fabric-graphql": {
    "type": "http",
    "url": "http://localhost:3000/mcp"
  }
}

I Copilot-chatten ber du först att introspekta schemat och försöker sedan ställa en relevant fråga som rör introspekterade data på naturligt språk, till exempel:

Cursor-IDE

Öppna markörinställningar

Lägg till MCP-serverkonfigurationen:

{
  "fabric-graphql": {
    "type": "http",
    "url": "http://localhost:3000/mcp"
  }
}

I chatten ber du först att du introspektar schemat och försöker sedan ställa en relevant fråga som rör introspekterade data på naturligt språk.

Det du har skapat

Grattis! Nu har du en fungerande GraphQL MCP-server som:

Autentiserar mot Fabric med autentiseringsuppgifter för tjänsteprincipal
Exponerar ditt Fabric-dataschema via introspektion
Översätter AI-agentbegäranden till GraphQL-frågor
Returnerar data i ett format som AI-agenter kan förstå och presentera

Dina AI-agenter (till exempel GitHub Copilot) kan nu:

Identifiera automatiskt vilka data som är tillgängliga i din Fabric-arbetsyta
Generera rätt GraphQL-frågor baserat på frågor om naturligt språk
Hämta och formatera resultat utan att du skriver någon frågekod

Den här lokala servern är avsedd för utveckling och inlärning. Följande avsnitt beskriver viktiga överväganden för produktionsdistributioner och vanliga felsökningsscenarier.

Säkerhetsfrågor

Även om den lokala GraphQL MCP-servern endast ska implementeras i utvecklingssyfte enligt beskrivningen i den här självstudien implementeras den med HTTP-transport, vilket gör det enklare att använda den som utgångspunkt för mer komplexa klientserver- eller webbaserade integreringar. Om du distribuerar GraphQL MCP-servrar i produktion:

Använda Azure Key Vault för att lagra hemligheter i stället för .env filer
Implementera rätt auktorisering, nätverkssäkerhet och brandväggsregler
Aktivera granskningsloggning för alla GraphQL-frågor
Använda Azure App Service eller Container Instances som värd
Implementera hastighetsbegränsning och autentisering för MCP-slutpunkter
Rotera regelbundet klienthemligheter och certifikat

Felsökning

Vanliga problem och lösningar

Autentiseringsfel

Kontrollera att din Azure App Registration har rätt behörigheter
Kontrollera att tjänstekontoprincipaler är aktiverade i Fabric-klienten
Kontrollera att klienthemligheten inte har upphört att gälla

Schema-introspektion misslyckas

Bekräfta att introspektion är aktiverat i dina GraphQL API-inställningar
Kontrollera att GraphQL-slutpunkts-URL:en är korrekt
Verifiera nätverksanslutningen till din Fabric-arbetsyta

AI-agenten känner inte igen verktyg

Starta om AI-klienten efter konfigurationsändringar
Kontrollera att MCP-serverns URL är tillgänglig
Kontrollera om det finns några felmeddelanden i serverloggarna

Frågeutförandefel

Granska serverkonsolen för loggade frågor och fel
Kontrollera att dina frågor matchar det tillgängliga schemat
Kontrollera att du har rätt behörigheter för begärda data

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-01-20

Dela via

Ansluta AI-agenter till Fabric API för GraphQL med en lokal MCP-server (Model Context Protocol)

Vad är MCP (Model Context Protocol)?

Varför GraphQL är idealiskt för MCP

Förutsättningar

Steg 1: Konfigurera åtkomst till tjänstens huvudkonto

Steg 2: Aktivera GraphQL-introspektion (kräver arbetsyteadministratör)

Steg 3: Konfigurera GraphQL MCP-servern

Klona exempellagringsplatsen

Installera beroenden

Konfigurera miljövariabler

Starta GraphQL MCP-servern

Tillgängliga MCP-verktyg

introspect-schema

query-graphql

Förstå arbetsflödet

Steg 4: Testa GraphQL MCP-servern

Verifiera serverns hälsotillstånd

Testa schema-introspektion

Testa en GraphQL-fråga

Steg 5: Ansluta AI-agenter

GitHub Copilot i Visual Studio Code

Cursor-IDE

Det du har skapat

Säkerhetsfrågor

Felsökning

Vanliga problem och lösningar

Relaterat innehåll

Feedback

Ytterligare resurser

`introspect-schema`

`query-graphql`