Categorieën bekijken

Hoe verbind je DuckDB met Claude/Cursor via MCP (DuckDB MCP-serverconfiguratie)?

Leestijd: 24 minuten

MCP-SERVER DUCKDB

Query DuckDB met Claude of Cursor via MCP.

Stel eenvoudige vragen over uw DuckDB-gegevens — gebeurtenissen, gebruikers, transacties, dagelijkse totalen, parquet-/CSV-/JSON-bestanden op uw lokale schijf of in S3 — via een beveiligde, alleen-uitgaande cloudverbinding, met Schema Intelligence ingebouwd in de DuckDB MCP-connector, zodat de AI in één keer de juiste, op analyses gerichte SQL-query's genereert.

Geen firewall-gaten Eén sleutel, elke connector Live data, geen cachevertraging Neem je eigen AI-tool mee.

Query Streams is een veilig, realtime data-integratieplatform dat elke database en SaaS API in uw account integreert in Claude, Cursor, ChatGPT en Grok — via één enkele MCP-sleutel en zonder dat er firewallwijzigingen nodig zijn. Deze handleiding beschrijft specifiek hoe u de DuckDB MCP-connector configureert, zodat uw AI-tool vragen in begrijpelijke taal kan beantwoorden over ingebedde analysedata — gebeurtenissen, gebruikers, transacties, dagelijkse totalen, cohortretentie, parquet-/CSV-/JSON-bestanden in S3 — zonder dat u CSV-exports vanuit de DuckDB CLI hoeft te kopiëren en plakken of handmatig code hoeft te schrijven. lees_park() vragen in een notitieboek. Meer informatie vindt u op QueryStreams.com en gratis aanmelden om je AI-tool echte DuckDB-vragen te gaan stellen.

Wat Query Streams MCP je biedt voor DuckDB

Andere "DuckDB MCP"-servers in het open-source-landschap verbinden de AI-tool rechtstreeks met een lokale server. .duckdb bestand. Dat werkt, maar het voegt een databasepad toe aan de configuratie van je AI-client, beperkt de AI-tool tot slechts dat ene DuckDB-bestand en geeft je geen auditlogboek van wat de AI daadwerkelijk heeft opgevraagd. De Query Streams MCP-server voor DuckDB lost een breder probleem op: één sleutel, elke connector (je DuckDB-bestanden plus al je andere databases en API's), een volledig auditlogboek en de AI-tool bewaart nooit je DuckDB-bestandspaden.

Geen inkomende firewall-gaten

De netwerkagent opent één versleutelde uitgaande cloudverbinding naar Query Streams. Uw AI-client maakt verbinding met de cloud, nooit met uw DuckDB-instantie. Er hoeft geen poort geopend te worden, geen IP-adres aan de whitelist toegevoegd te worden, geen VPN gebruikt te worden en er worden geen DuckDB-bestandspaden of -inloggegevens in de AI-clientconfiguratie weergegeven.

Eén sleutel, elke connector

Dezelfde MCP-sleutel heeft toegang tot elke database en SaaS-API waarmee uw account is verbonden. Voeg morgen een Stripe- of PostgreSQL-connector toe en de AI-tool herkent deze direct naast uw DuckDB-bestanden – allemaal in één catalogus – zonder dat u de sleutel opnieuw hoeft in te voeren.

Schema-intelligentie ingebouwd

De AI ziet door AI samengestelde beschrijvingen, semantische typen, lijsten met enumeraties, hints over de vorm van JSON/STRUCT en ontdekte foreign keys voor elke DuckDB-kolom – niet alleen kale gegevens. informatie_schema output. Het genereert direct analysegerichte DuckDB SQL (parket lezen, datum_afgekapt, SCHARNIER, KWALIFICEREN) zelfs op heterogene schema's met gemengde bestands- en tabelgebaseerde bronnen.

Alleen-lezen is verplicht bij de agent.

Zelfs een hallucinerende LLM kan geen VERWIJDEREN, UPDATE, INVOEGEN, of KOPIËREN ... NAAR via Query Streams MCP. De netwerkagent weigert alles wat niet SELECT, MET, of UITLEGGEN voordat DuckDB de SQL-query überhaupt ziet — en de agent opent lokale .duckdb Bestanden worden standaard in alleen-lezenmodus weergegeven.

Per-toets snelheidslimieten

Standaard 60 verzoeken per minuut en 10 uitvoeringsoproepen per minuut, configureerbaar per sleutel. Een oncontroleerbare lus van AI-tooloproepen belandt in een tokenbucket, niet in het procesgeheugen van DuckDB of op de lokale schijf.

Hoe het werkt zonder firewallpoorten te openen

De Query Streams Network Agent wordt eenmalig geïnstalleerd op de machine waarop uw lokale gegevens staan. .duckdb bestand (een laptop, een lokale server of een kleine virtuele machine) en maakt één uitgaande TLS-verbinding met de cloud — er wordt nooit inkomend verkeer blootgesteld en de AI-tool ziet uw gegevens nooit. .duckdb bestandspad. Hoe werkt een verbinding die alleen uitgaand verkeer toelaat? →

AI-client

Cursor, Claude,
ChatGPT, Grok

QS MCP-server

Streambare HTTP
X-MCP-sleutel authenticatie

Netwerk Agent

Op uw netwerk
Cloud-verbinding uit

DuckDB

Lokaal
.duckdb-bestand

Geen inkomende poort nodig — de agent belt uit, nooit andersom.

De MCP-toets die je aan Cursor of Claude geeft, is beperkt (lezen / analyseren / uitvoeren), op elk moment herroepbaar en met een limiet per sleutel. De AI-tool roept deze MCP-tools aan om zijn werk te doen:

querystreams-mcp · toolcatalogus
qs_list_organizationslezen
Retourneert de organisatie die is gekoppeld aan de aanroepende sleutel.
qs_list_agentslezen
Geeft een overzicht van netwerkagenten en hun online status.
qs_list_connectorslezen
Geeft een overzicht van data-connectoren (één item per databaseserver of API).
qs_get_connector_schemalezen
Geeft de DuckDB-databases, schema's, tabellen en kolommen terug die de AI kan bevragen (inclusief hints voor JSON-, STRUCT- en LIST-typen), met Schema Intelligence-verrijking indien beschikbaar.
qs_profiel_tabelanalyseren
Voorbeeldwaarden, verdelingen, enumeratiedetectie, semantische typen — op aanvraag.
qs_list_saved_querieslezen
Voorgebouwde, geparameteriseerde SQL-sjablonen die het team vertrouwt. De AI voert ze uit zonder ooit de SQL-code te zien.
qs_run_saved_queryuitvoeren
Voert een opgeslagen query uit door patroon_sleutel met optionele parameteroverrides.
qs_run_queryuitvoeren
Voert een SELECT-query uit op een connector. Een alleen-lezen validator wordt uitgevoerd op de agent, voordat DuckDB de SQL-query te zien krijgt.

Waarom Schema Intelligence Query Streams MCP anders maakt

De meeste "MCP for DuckDB"-servers in het open-source landschap bieden je AI-tool dezelfde functionaliteit. informatie_schema DuckDB geeft je een onbekende. Kolomnamen. Gegevenstypen. Misschien een primaire sleutel. De LLM moet maar raden wat er aan de hand is. event_type = 7 betekent, wat nuttige lading opslag binnen de STRUCT, of gebeurtenissen.gebruikers_id sluit zich daadwerkelijk aan bij gebruikers.id (DuckDB-schema's hebben vaak geen gedeclareerde foreign keys, vooral wanneer tabellen zijn samengesteld uit parket lezen / read_csv_auto bronnen). Daarom is de eerste SQL-query die de meeste LLM's uitvoeren op een kaal schema onjuist — niet omdat de LLM slecht is, maar omdat deze niet over de benodigde gegevens beschikt om correct te zijn.

Query Streams MCP retourneert hetzelfde schema, verrijkt met wat wij noemen Schema-intelligentie (SI) — Door AI samengestelde metadata die wordt gegenereerd door profileringsquery's uit te voeren op uw gegevens. werkelijke DuckDB-gegevens voordat de AI-client erom vraagt. Wanneer SI is ingeschakeld op een connector en database, worden alle schematools die de AI aanroept (qs_get_connector_schema, qs_get_table_schema, qs_profiel_tabel, qs_get_relationships) retourneert het kale schema plus zes lagen aan zorgvuldig samengestelde kennis — inclusief hints over de JSON/STRUCT-vorm en richtlijnen voor kolomprojectie voor de kolomgeoriënteerde I/O van DuckDB. De LLM maakt een einde aan het giswerk.

Om dit concreet te maken, volgt hier wat de AI-client terugkrijgt van een enkele opdracht. qs_get_table_schema een oproep naar een typisch DuckDB embedded-analytics datawarehouse (evenementen, gebruikers, transacties, dagelijkse_aggregaten, experimenten) — eerst zonder schema-intelligentie, daarna mét.

Zonder schema-intelligentie data_source: vastgelegd_schema
// Wat de LLM ziet == TABEL: evenementen == – id UBIGINT [PK] – gebruikers-ID UBIGINT NOT NULL – event_type VARCHAR NOT NULL – tijdstempel TIJDSTEMPEL NIET NULL – nuttige lading STRUCTUUR(…) - bron VARCHAR == TABEL: gebruikers == – id UBIGINT [PK] – e-mail VARCHAR – cohort VARCHAR – aanmelden_bij TIJDSTEMPEL == TABEL: transacties == – id UBIGINT [PK] – gebruikers-ID UBIGINT NOT NULL - hoeveelheid DUBBEL NIET NULL - munteenheid VARCHAR(3) – gebeurde_op TIJDSTEMPEL NIET NULL == TABEL: dagelijkse_aggregaten == – dag DATUM – metrische_naam VARCHAR – metrische_waarde DUBBELE == TABEL: experimenten == – id UBIGINT [PK] - naam VARCHAR – variant VARCHAR Externe sleutels: (niets opgegeven) si_aanbeveling: staat: “niet_uitvoeren” Wat je mist voor dit gesprek: – Door AI ontdekte foreign keys – Voorbeeldwaarden per kolom + enum-detectie – Tabel- en kolombeschrijvingen – Semantische typeclassificaties – Hints voor STRUCT/LIST-vorm (DuckDB) Opmerking: “Alleen typen, geen semantische context”
Met schema-intelligentie data_source: schema_intelligence
// Wat de LLM ziet == TABEL: evenementen [FEIT, domein:product] == “Productanalysegebeurtenissen; één rij per gebruikersactie. Tabel met veel gegevens.” – gebruikers-ID UBIGINT identificator FK -> users.id (100% overlap, conf 0.99) – event_type VARCHAR status_code (enum) paginaweergave (54%) | klik (22%) | aankoop (14%) | aanmelding (6%) | opzegging (4%) – tijdstempel TIJDSTEMPEL tijdstempel Voorbeeld: 2026-04-28 14:02:11.234 – nuttige lading STRUCTUUR(…) gestructureerd (UNNEST aanbevolen) Velden: pagina, verwijzer, ab_variant, apparaat == TABEL: gebruikers [DIM, domein:klanten] == “Gebruikersdimensie; cohortanalyse is leidend voor retentie- en segmentatieanalyses.” – e-mail VARCHAR e-mail Voorbeeld: [email protected], [email protected] – cohort VARCHAR segment (enum) 2026-Q1 (28%) | 2026-Q2 (24%) | 2025-Q4 (22%) | ouder (26%) – aanmelden_bij TIJDSTEMPEL tijdstempel == TABEL: transacties [FEIT, domein:inkomsten] == “Omzetgebeurtenissen; SOM(bedrag) is GMV. Het bedrag is uitgedrukt in belangrijke valuta-eenheden.” – gebruikers-ID UBIGINT identificator FK -> users.id (98% overlap, conf 0.96) - hoeveelheid DUBBELE munteenheid Bereik: 0,99 – 1.840,00 · gemiddelde 47,20 – gebeurde_op TIJDSTEMPEL tijdstempel == TABEL: dagelijkse_aggregaten [FEIT, domein:product] == – metrische_naam VARCHAR status_code (enum) Voorbeeld: ['DAU','WAU','MAU','omzet','retentie_d7′] – metrische_waarde DUBBELE numeriek

De zes lagen die Schema Intelligence toevoegt

Elke laag behandelt een type vraag waar de LLM anders alleen maar naar zou gissen. De optionele SI-profileringsstap wordt uitgevoerd op uw DuckDB-gegevens zonder uw schema te wijzigen — en voor de scan opent de agent lokale bestanden. .duckdb bestanden in alleen-lezenmodus. Wat Schema Intelligence toevoegt en hoe het actueel blijft →

Door AI samengestelde beschrijvingen

Een duidelijke, in begrijpelijke taal geformuleerde beschrijving van het doel van elke database, elk schema, elke tabel en elke kolom — eenmalig gegenereerd en automatisch bijgewerkt wanneer uw schema wijzigt. Betrouwbaarheidsscore; beschrijvingen van gebruikers hebben altijd de voorkeur.

evenementen: “Productanalyses
gebeurtenissen; één rij per actie.”

Tabelclassificaties

Elke tabel is gelabeld met FACT (transactionele gebeurtenissen), DIM (beschrijvende verwijzing) of LOOKUP (kleine code-mapping), plus een bedrijfsdomein — product, verkoop, financiën, ondersteuning en nog 16 andere.

gebeurtenissen [FEIT, domein:product]
gebruikers [DIM, domein:klanten]

Semantische typen per kolom

Achttien typen: valuta, e-mail, tijdstempel, statuscode, percentage, rankingpositie, identificatiecode, URL, persoonsnaam en meer. De AI genereert voor elk type een analysegerichte DuckDB SQL-query (bijv. date_trunc('week', ts) voor tijdstempels).

bedrag: valuta · e-mail: e-mail
tijdstempel: tijdstempel

Voorbeeldwaarden uit echte gegevens

Willekeurige rijen werden aan het LLM-model getoond, waardoor het patronen herkent die geen enkel schema kan weergeven: veldnamen in STRUCT-bestanden, de vorm van LIST-elementen, opmaakconventies en de feitelijke codering van uw VARCHAR-kolommen.

payload (STRUCT): {pagina, verwijzer,
ab_variant, apparaat}

Enum-detectie met distributies

Kolommen met een lage cardinaliteit (50 of minder unieke waarden, maximaal 5% van de rijen uniek) worden gekoppeld aan hun volledige waardelijst met rijtellingen. De AI raadt nooit hoofdletters of spelling bij enum-vormige kolommen. VARCHAR kolommen.

event_type: page_view (54%) | click (22%)
| aankoop (14%) | aanmelding (6%) | opzegging (4%)

Impliciete ontdekking van vreemde sleutels

Analyse van overlappingen in gegevens tussen tabellen vindt joins die niet zijn gedeclareerd als DDL-beperkingen — wat vaak voorkomt in DuckDB-schema's die zijn gebouwd op Parquet-/CSV-bestandsimporten. Deze worden opgeslagen naast formele foreign keys met betrouwbaarheidsscores, die worden geretourneerd door qs_get_relationships.

events.user_id -> users.id
(100% overlap, conf 0,99)

Dezelfde prompt, andere SQL-query

Het bewijs zit in de SQL-query's die de AI-tool daadwerkelijk genereert. Dezelfde cursorsessie, hetzelfde Claude-model, dezelfde prompt. "Toon me de omzetontwikkeling per cohort en evenementtype voor het laatste kwartaal, met wekelijkse gegevens." Zonder schema-intelligentie moet de LLM gissen. Met schema-intelligentie schrijft de LLM in één keer idiomatische, kolomvriendelijke DuckDB SQL.

Zonder schema-intelligentie
— LLM's eerste poging tegen een kaal schema: SELECT *, EXTRACT(ISOWEEK VAN tijdstempel) AS week, SUM(bedrag) AS omkeer VAN evenementen JOIN transacties GEBRUIKEN(gebruikers-ID) WAAR tijdstempel >= '2025-01-01' GROEP DOOR 1, 2 SELECT * maakt kolomprojectie ongedaan EXTRACT(ISOWEEK …) — geen DuckDB-eigenschap Het bedrag heeft betrekking op transacties, niet op gebeurtenissen. geen cohort — users.cohort is het segment vastgelegde datum — "laatste kwartaal" is dynamisch geen read_parquet() — als events een bestand is
Met schema-intelligentie
— LLM's eerste poging met SI ingeschakeld: SELECT u.cohort, e.event_type, datum_afgekapt('week', e.timestamp) AS week, SUM(t.bedrag) AS inkomsten VAN evenementen e JOIN gebruikers u OP u.id = e.user_id JOIN transacties t OP t.user_id = e.user_id WAAR e.timestamp >= HUIDIGE_DATUMINTERVAL 90 DAG GROEP DOOR u.cohort, e.event_type, wk KWALIFICEREN RANG() OVER(PARTITIONEREN DOOR u.cohort ORDER BY inkomsten DESC) <= 5 ORDER BY u.cohort, week Met één keer goed. Kolomprojectie. FACT/DIM-tags gaven richting aan de joinstructuur. FK-ontdekking bracht gebeurtenissen aan het licht: events.user_id -> users.id date_trunc('week', ts) — DuckDB-native QUALIFY filtert de resultaten van het venster, geen subquery HUIDIGE_DATUM – INTERVAL n DAG — DuckDB-idioom
Wil je Schema Intelligence niet uitvoeren? MCP werkt nog steeds — schema-tools retourneren kale metadata (typen, primaire sleutels, formele externe sleutels, indexen) en elke verslechterde respons bevat een si_aanbeveling Een blok dat de AI vertelt wat er ontbreekt, inclusief een optie om SI tijdens een gesprek in te schakelen met één telefoontje. qs_request_si_analysis. Hoe Schema Intelligence werkt en hoe lang het duurt →

Een lokaal DuckDB-bestand uitvoeren via Query Streams MCP

Query Streams MCP maakt verbinding met lokale DuckDB-databasebestanden. De netwerkagent opent uw .duckdb Het bestand wordt in de alleen-lezenmodus van DuckDB opgeslagen en de query's worden via dezelfde uitgaande cloudverbinding en dezelfde MCP-sleutel als bij alle andere connectors naar uw AI-client verzonden — er is geen aparte databaseserver nodig.

Lokaal .duckdb bestand

Alleen-lezen

De agent opent uw .duckdb Het bestand wordt in de alleen-lezenmodus van DuckDB geopend en de query's worden verwerkt via de ingebouwde bibliotheek. Ondersteunt elk formaat dat op de lokale schijf past — er zijn geen gelijktijdige schrijfprocessen nodig. Ideaal voor ontwikkellaptops, CI-testomgevingen, ingebedde rapportage en persoonlijke analyses van Parquet-/CSV-importen die via DuckDB zijn opgebouwd. lees_park() + CREATE TABLE ASRegistreer meer dan één .duckdb Plaats het bestand op dezelfde agent en laat de LLM de verbindingsnaam bepalen.

connector/data/analytics.duckdb

Schema Intelligence wordt uitgevoerd op basis van uw lokale DuckDB-bestand. De SI-scan leest de .duckdb Het bestand wordt via uw netwerkagent op uw eigen computer verzonden — nooit in de cloud. De cloudverbinding van de agent naar Query Streams is één per agent, ongeacht het aantal DuckDB-bestanden. Je hebt je geregistreerd.

Nova AI

Is MCP niet jouw ding? Probeer dan Nova AI eens.

Sla de JSON-configuratie volledig over: Nova AI is geïntegreerd in het Query Streams-webportaal. en stelt dezelfde eenvoudige DuckDB-vragen aan je lokale .duckdb bestand — dezelfde agent, dezelfde alleen-lezen-handhaving, dezelfde schema-intelligentie, geen MCP-infrastructuur.

Maak kennis met Nova AI

Vereisten

Voordat je begint, zorg ervoor dat je het volgende hebt:

  1. Een gratis Query Streams-account bij mijn.querystreams.nl.
  2. De Query Streams Network Agent is geïnstalleerd op een machine waarop uw lokale gegevens staan. .duckdb bestand (een laptop, server of kleine VM) — zie Download de Query Streams Agent..
  3. Een DuckDB-connector geconfigureerd voor de agent — zie de bestaande connector instellen handleidingen voor de .duckdb Het bestandspad. De agent bewaart het pad; de AI-tool raakt het nooit aan.
  4. Elke AI-client die MCP ondersteunt. In deze handleiding laten we Cursor, Claude Desktop, ChatGPT en Grok zien; als je Windsurf, Zed, Continue, Cline, VS Code Copilot, Codex of Goose gebruikt, is het configuratieblok in principe hetzelfde.
  5. Vijf minuten.
Je hoeft de agent maar één keer in te stellen. Dezelfde agent die de Excel- en Google Sheets-add-ons van Query Streams, de webgebaseerde Query Builder en Nova AI aandrijft, wordt ook gebruikt voor MCP. Het toevoegen van MCP aan een bestaand Query Streams-account is slechts een kwestie van het genereren van een sleutel; de agent en de DuckDB-connector draaien al.
1

Genereer een MCP-sleutel

Van de /mcp Ga naar de pagina Query Streams en genereer een sleutel met de gewenste scopes.

2

Sleep het naar je AI-client.

Eén JSON-fragment voor Cursor, Claude, ChatGPT of Grok. Dezelfde sleutel overal.

3

Stel een vraag

"Hoe zag onze cohortretentiecurve er de afgelopen 12 weken uit?" — de AI roept de juiste tools aan en je krijgt het antwoord.

Stap 1: Genereer een MCP-sleutel in Query Streams

Meld u aan bij Query Streams en open de MCP-pagina (of meld u eerst aan bij mijn.querystreams.nl en klik MCP (in de linkernavigatie). Klik Sleutel genererenGeef de sleutel een herkenbare naam (iets zoals cursor-laptop of claude-desktop), en kies de bereiken die je aan deze sleutel wilt toevoegen:

  • lezen — De AI kan connectoren doorzoeken en schema's lezen. Dat is voor al het andere nodig.
  • analyseren — De AI kan tabellen profileren en relaties ontdekken (voorbeeldwaarden, verdelingen, semantische typen, hints over de structuur/lijst-vorm). Optioneel, maar sterk aanbevolen voor DuckDB-werk, waar inzicht in de structuur van geneste gegevens en de kardinaliteit van kolommen in enum-stijl ervoor zorgt dat de LLM in één keer kolomvriendelijke analyse-SQL kan schrijven.
  • uitvoeren — De AI kan daadwerkelijk SQL-query's uitvoeren. Zonder dit kan de AI alleen schema-metadata lezen.

Voor een typische workflow zoals "Laat Claude mijn DuckDB-gegevens analyseren", zijn alle drie de scopes geschikt. Voor een sleutel die je aan een teamlid of een minder vertrouwde klant geeft, laat je deze scope weg. uitvoeren en laat ze alleen browsen. Je kunt elke sleutel op elk moment vanaf dezelfde pagina intrekken; de AI-client zal dit zien. MCP_KEY_REVOKED Bij de volgende oproep stopt het direct met werken. Er is geen vertraging in de signaaloverdracht.

Kopieer de sleutel nu — Query Streams toont deze eenmalig en slaat vervolgens alleen een hash op. Als u de sleutel kwijtraakt, genereer dan een nieuwe. De sleutel ziet er als volgt uit: qsmcp_ gevolgd door 48 willekeurige tekens, en dat is wat uw AI-client verzendt in de X-MCP-sleutel verzoekheader.

Stap 2: Voeg Query Streams MCP toe aan uw AI-client

De configuratie heeft dezelfde vorm voor elke MCP-compatibele client: een MCP-serververmelding die verwijst naar https://mcp.querystreams.com met uw sleutel in de X-MCP-sleutel Koptekst. Kies hieronder uw klant.

Cursor
Cursor ~/.cursor/mcp.json
// Bewerk ~/.cursor/mcp.json
{
  "mcpServers": {
    "querystreams": {
      "url": "https://mcp.querystreams.com",
      "kopteksten": {
        "X-MCP-sleutel": "qsmcp_PLAK_HIER_SLEUTEL_"
      }
    }
  }
}
Claude Desktop
Claude Desktop claude_desktop_config.json
// Instellingen → Ontwikkelaar → Configuratie bewerken
{
  "mcpServers": {
    "querystreams": {
      "url": "https://mcp.querystreams.com",
      "kopteksten": {
        "X-MCP-sleutel": "qsmcp_PLAK_HIER_SLEUTEL_"
      }
    }
  }
}
ChatGPT
ChatGPT Apps en connectoren
// Instellingen → Apps en connectors → MCP toevoegen
Server-URL  https://mcp.querystreams.com
Auth-header X-MCP-sleutel
Kopwaarde qsmcp_PLAK_HIER_SLEUTEL_

// Vereist een betaald ChatGPT-abonnement
// (Plus / Pro / Team / Enterprise).
Grok
Grok Externe MCP-tools
// Grok → Instellingen → Hulpmiddelen
{
  "mcp_servers": [{
    "naam": "querystreams",
    "url": "https://mcp.querystreams.com",
    "auth_header": "X-MCP-sleutel",
    "auth_value": "qsmcp_..."
  }]
}

Start uw AI-client opnieuw op. Bij de volgende opstart zal deze de acht hierboven vermelde Query Streams MCP-tools detecteren en in het toolpalet weergeven. In Cursor en Claude Desktop kunt u dit controleren door te typen “lijstconnectoren” — de AI zou moeten bellen qs_list_connectors en retourneer uw DuckDB-connector samen met alles wat u verder hebt geconfigureerd.

Stap 3: Stel de AI een DuckDB-vraag

Je hoeft geen SQL te schrijven, dat doet de AI. Je stelt een vraag, de AI kiest de juiste MCP-tool, de agent voert de query uit op je DuckDB-database en het antwoord krijg je terug als tekst plus tabellen. Drie voorbeeldvragen om mee te beginnen:

“Hoe ziet onze cohortretentiecurve eruit over de afgelopen 12 weken?”
Behoud
De AI-oproepen qs_get_connector_schema om te ontdekken evenementen, gebruikers, en transacties tabellen, dan qs_run_query met een SELECT die samenvoegt gebruikers naar evenementenemmers van date_trunc('week', signup_at) voor de cohortas en date_trunc('week', e.timestamp) - signup_at voor de retentie-as, en berekent COUNT(DISTINCT user_id) genormaliseerd op basis van cohortgrootte. Je ziet het resultaat direct als een driehoekige retentietabel met wekelijkse intervallen, plus een schriftelijke interpretatie die aangeeft welke cohorten het beste retentiepercentage behalen en waar de curve afneemt. De AI heeft dit allemaal afgeleid uit de DuckDB-gegevens zonder dat je ook maar één SQL-query hoeft te schrijven.
"Laat me het voortschrijdend gemiddelde over 90 dagen van de omzet per categorie zien."
Winst
De AI gebruikt de door DuckDB ontwikkelde datumberekeningen (HUIDIGE DATUM - INTERVAL VAN 90 DAGEN) om het venster te begrenzen, voegt zich samen transacties naar evenementen voor categorietoewijzing, en is van toepassing GEMIDDELDE(SOM(bedrag)) OVER (PARTITIONEREN OP categorie ORDEREREN OP dag RIJEN TUSSEN 89 VOORGAANDE EN HUIDIGE RIJ) als een vensterfunctie. Het resultaat is een gerangschikte tabel met categorie, huidig 90-daags voortschrijdend gemiddelde en procentuele verandering ten opzichte van de voorgaande 90 dagen. De AI annoteert doorgaans de grootste stijger en de grootste daler zonder dat u erom hoeft te vragen. De kolomgeoriënteerde engine van DuckDB maakt dit snel, zelfs bij gebeurtenisstromen met miljarden rijen.
Welke segmenten groeien het snelst van week tot week?
Groei
De AI gebruikt de enum-detectie van Schema Intelligence op gebruikers.cohort om de segmenten op te sommen, schrijft vervolgens een CTE die actieve gebruikers per segment aggregeert. (cohort, week) via date_trunc('week', timestamp), is van toepassing KWALIFICEREN met een VERTRAGING() Het venster voor de vergelijking met de voorgaande week retourneert segmenten gesorteerd op week-op-week groeipercentage. Het resultaat is een gerichte lijst met cohort, actieve gebruikers van deze week, actieve gebruikers van vorige week en week-op-week procentuele verandering — meestal sorteert de AI eerst op de grootste positieve delta en markeert alle segmenten die van negatieve naar positieve groei zijn omgeslagen. observatielijstgroepen.

De eerste keer dat de AI een tool aanroept, kan er in uw client een bevestigingsmelding verschijnen waarin u wordt gevraagd de tooloproep goed te keuren. Dit is de standaard toestemmingsprocedure van MCP en geen extra functie van Query Streams. Keur de oproep eenmaal goed en de AI kan de rest van het gesprek zonder problemen voortzetten. U kunt de toestemming op elk gewenst moment opnieuw bekijken in de instellingen van uw client.

Eerlijke factuurmelding: MCP-gebruik wordt gefactureerd op basis van niet-gecomprimeerde bytes.

De Excel-add-in van Query Streams, de Google Sheets-add-on, de webquerybuilder en Nova AI draaien allemaal via onze gecomprimeerde cloudverbinding — wij meten en factureren. gecomprimeerde bytes tegen uw gegevensdomein. Het MCP-transport (Streamable HTTP volgens de officiële MCP-specificatie) ondersteunt geen betrouwbare end-to-end compressie over elke client en tussenliggende proxy, daarom meten en factureren we. uncompressedBytes voor MCP-verkeer.

  • Wat dit betekent: Een DuckDB-analyseresultaatset van 2 MB kost ongeveer 2 MB van uw data-resources wanneer deze via MCP wordt opgehaald, vergeleken met ongeveer 250-350 KB via Excel/Sheets/Nova/de Query Builder. Kolomgegevens in DuckDB — met name geaggregeerde uitvoer met herhaalde categorie- en tijdstempelwaarden — worden ongeveer 6-8 keer gecomprimeerd via LZ4, waardoor het verschil in grootte hier groter is dan bij transactionele databases. Dezelfde gegevens, ander transport, andere factureerbare grootte.
  • Wat dit níét is: Een toeslag of een straf voor het gebruik van MCP. We geven de daadwerkelijk verzonden bytes door. De andere clients zijn goedkoper omdat compressie betrouwbaar werkt op die transportprotocollen; we straffen je niet voor de protocolkeuze, maar we moeten wel transparant zijn over de kostenstructuur.
  • Wat u kunt doen: Voor zeer grote, terugkerende query's (bijvoorbeeld het exporteren van gebeurtenissen met miljoenen rijen rechtstreeks vanuit een DuckDB-kolomopslag) is de aanpak met Excel/Sheets/Nova de beste keuze. Voor interactieve AI-toolaanroepen (de typische geaggregeerde DuckDB-respons van 100-5000 rijen die in een LLM-context past) is MCP de juiste keuze en het kostenverschil is slechts een paar cent.

Veelgestelde vragen

Moet ik poorten openen of een VPN-verbinding gebruiken om dit te kunnen gebruiken? +
Geen inkomende regels, port-forwarding, NAT punchthrough of VPN. De netwerkagent maakt één uitgaande TLS-verbinding (poort 443) en uw AI-client bereikt https://mcp.querystreams.com vanaf het openbare internet — als uitgaande HTTPS werkt op de agenthost, werkt MCP. Zie hoe de verbinding die alleen uitgaand verkeer toelaat werkt →
Welke AI-tools kan ik gebruiken met Query Streams MCP? +
Elke client die het open Model Context Protocol ondersteunt, zoals Claude Desktop, Claude Code, Cursor, ChatGPT (betaald), Grok, Gemini CLI, Windsurf, Zed en meer dan 500 andere, is geschikt. Gebruik je eigen AI-tool; je hoeft niet over te stappen. Volledige lijst met ondersteunde AI-clients →
Kan ik een MCP-sleutel intrekken? +
Ja, drie onafhankelijke noodstopknoppen (per toets vanaf de /mcp pagina, per organisatie via planinstellingen en platformniveau), en geen van deze opties vereist een databasewachtwoordrotatie of een herstart van de agent. Meer informatie over de beveiliging van MCP-sleutels →
Hoe worden de MCP-kosten in rekening gebracht voor mijn datadomein? +
MCP maakt gebruik van hetzelfde databudget als Excel, Sheets, de Query Builder en Nova, maar het Streamable HTTP-transport van MCP kan niet betrouwbaar van begin tot eind comprimeren, waardoor er kosten in rekening worden gebracht. uncompressedBytes in plaats van gecomprimeerde bytesVoor DuckDB is dit verschil groter dan voor transactionele databases: kolomgeoriënteerde uitvoer wordt ongeveer 6-8 keer gecomprimeerd via LZ4 op de gecomprimeerde clients, waardoor een analyseresultaat van 2 MB ongeveer 250-350 KB kost via Excel/Sheets/Nova, vergeleken met ongeveer 2 MB via MCP. Hoe werkt data-realm-facturering over verschillende transportprotocollen heen?
Werkt Query Streams MCP met DuckDB 0.9 / 0.10 / 1.0, de alleen-lezenmodus van DuckDB en DuckDB-extensies zoals httpfs / parket / json / ruimtelijke? +
Ja, de Network Agent ondersteunt DuckDB 0.9+ via de standaardmethode. duckdb bibliotheek (momenteel versie 1.0 meegeleverd). De alleen-lezenmodus is de standaardinstelling van de agent voor de veiligheid.zodat meerdere lezers hetzelfde kunnen delen. .duckdb Bestand zonder conflicten over schrijflocks. Extensies: httpfs (S3/HTTPS-leesbewerkingen, inclusief authenticatie met ondertekende URL's en IAM-rolketens), parket (parket I/O via lees_park() en KOPIËREN ... NAAR — de laatste werd geblokkeerd door de alleen-lezen validator), json (JSON lezen/uitpakken via read_json_auto() en de json_extract familie), en ruimtelijke (PostGIS-compatibele geometrietypen, GDAL-ondersteunde leesbewerkingen van GeoJSON / Shapefile / FlatGeobuf) worden allemaal ondersteund. De agent laadt ze automatisch wanneer een SI-scan het gebruik ervan detecteert. Neem voor aangepaste extensies of extensies van de community contact op met de supportafdeling — we kunnen ze op de whitelist van de agent plaatsen. .duckdb Het bestand dat u registreert, is een aparte connector; u kunt meerdere DuckDB-bestanden tegelijk registreren en de LLM het bestand op naam laten selecteren (bijvoorbeeld "Vraag de DuckDB-server in de stagingomgeving op, niet in de productieomgeving.").
Wat is het verschil tussen dit en het zelf draaien van een open-source DuckDB MCP-server? +
Een directe DuckDB MCP-server (er bestaan communityprojecten, waaronder die van DuckDB Labs zelf) is één MCP per gegevensbron. Om Claude te laten lezen vanuit je DuckDB + Google Search Console + je Stripe-account + je Snowflake-datawarehouse, heb je vier MCP-servers nodig die afzonderlijk geconfigureerd zijn in elke AI-client, elk met zijn eigen inloggegevens, elk met zijn eigen bereikmodel en elk met zijn eigen auditlogboek. Query Streams MCP is één sleutel die toegang biedt tot elke connector die aan je account is gekoppeld. Je krijgt ook Schema Intelligence (met DuckDB-bewuste STRUCT/LIST-vormhints en richtlijnen voor kolomprojectie), handhaving van alleen-lezen op agentniveau, snelheidslimieten per sleutel en een auditlogboek. gebeurtenislogboekenen dezelfde data-realm factureringspipeline die u al gebruikt — geen van beide biedt een direct DuckDB MCP-abonnement.
Wat gebeurt er als de AI probeert gegevens te schrijven of te verwijderen? +
Het wordt door de agent afgewezen voordat de gegevensbron de SQL-query ziet. Elke qs_run_query Het gesprek wordt verwerkt door een hardgecodeerde, alleen-lezen validator die alleen dit toestaat. SELECT, MET, en UITLEGGEN verklaringen; al het andere (inclusief KOPIËREN ... NAAR schrijft, MAAK TABEL, BIJVOEGENen DuckDB's LADEN / INSTALLEREN (voor extensies die niet op de whitelist staan) retourneert ALLEEN-LEZEN_SCHENDING en bereikt DuckDB nooit. De validator draait in het agentproces op uw netwerk, niet in de cloud, dus een gecompromitteerde cloudomgeving zou deze niet kunnen omzeilen. Voor lokale .duckdb bestandenBovendien opent de agent het bestand in de alleen-lezenmodus van DuckDB, waardoor zelfs een hypothetische omzeiling van de validator niet via de databasehandle kan schrijven.
Kan ik zien wat de AI precies heeft gevraagd? +
Ja. Elke aanroep van een MCP-tool schrijft een regel naar gebeurtenislogboeken met de organisatie, gebruiker, sleutel, bereik, latentie en resultaatcode. De organisatiebeheerder kan met één query antwoord geven op de vraag: "Wie heeft MCP vorige week gebruikt, welke connector en wat hebben ze gevraagd?" Merk op dat we de gegevens loggen. naam en metadata van het hulpmiddelNiet de SQL-tekst of de geretourneerde rijen — die gaan via de cloudverbinding en komen nooit in de cloudlogboeken terecht. Als u een volledige SQL-audit wilt, schakelt u logboekregistratie aan de engine-zijde in waar die beschikbaar is; voor DuckDB betekent dit specifiek het gebruik van PRAGMA enable_profiling + PRAGMA-profiel_uitvoer Tijdens elke sessie moeten EXPLAIN-plannen worden vastgelegd. .duckdb Bestanden hebben geen ingebouwd auditlogboek. Als u de volledige SQL-query per query wilt vastleggen, start u de agent zelf met uitgebreide querylogging ingeschakeld (de agent schrijft de geparseerde SQL naar zijn lokale logbestand voordat deze naar DuckDB wordt doorgestuurd).
Moet ik Schema Intelligence uitvoeren om Query Streams MCP te kunnen gebruiken? +
Nee - Schema-intelligentie is optioneel. En MCP werkt ook zonder (de AI krijgt het kale schema en schrijft eenvoudige query's). Met SI ingeschakeld voegen de zes samengestelde lagen de DuckDB-specifieke context toe die LLM nodig heeft: STRUCT-veldnamen en LIST-elementvormen in de voorbeeldwaarden, semantische typen die analytisch georiënteerde idiomen aansturen (parket lezen, datum_afgekapt, SCHARNIER, KWALIFICEREN), en door AI ontdekte vreemde sleutels via qs_get_relationships — vooral waardevol voor DuckDB-schema's die zijn samengesteld uit parket lezen / read_csv_auto bronnen waar formele FK's zelden worden gedeclareerd. Zonder SI bevat elke schema-tool-respons een si_aanbeveling blokkering waarop de AI kan reageren om een actie te starten midden in een gesprek via qs_request_si_analysis. De zes lagen die Schema Intelligence toevoegt en hoe lang een scan duurt →
Wat als ik later nog een connector toevoeg, zoals Stripe of PostgreSQL? +
Aan de clientzijde verandert er niets — dezelfde sleutel bereikt de nieuwe connector zodra de agent deze koppelt.qs_list_connectors (wordt automatisch opgepakt). Eén configuratieblok koopt je hele account, zowel het huidige als het toekomstige. Waarom één sleutel alle connectoren dekt →
Moet ik MCP instellen om met mijn data te kunnen chatten? +
Nee - Nova AI is geïntegreerd in het Query Streams-portaal. Het werkt met elke connector (inclusief DuckDB) zonder dat er MCP-instellingen of configuratiebestanden nodig zijn. Gebruik Nova om met je data te communiceren binnen Query Streams; gebruik MCP wanneer je wilt dat je eigen AI-client (Claude, Cursor, ChatGPT, …) dezelfde data kan benaderen — dezelfde agent, dezelfde connectors, dezelfde Schema Intelligence eronder. Leer meer over Nova AI →
Kan ik meerdere DuckDB-bestanden registreren of parquet-/CSV-gegevens analyseren? +
Ja. De agent opent elke lokale vestiging. .duckdb Bestand in alleen-lezenmodus via de ingebouwde bibliotheek — geen apart serverproces nodig. Om Parquet/CSV/JSON te analyseren, bouwt u een .duckdb bestand met lees_park() / read_csv_auto() + CREATE TABLE AS en wijs de agent erop. U kunt er meerdere registreren. .duckdb bestanden op één agent (bijv. lokale-dev.duckdb + analytics.duckdb) en laat de LLM de ambiguïteit op basis van de connectornaam in gewoon Engels oplossen ("Vraag de DuckDB-server in de stagingomgeving op, niet in de productieomgeving."De cloudverbinding met Query Streams is één uitgaande TLS-verbinding per agent, ongeacht hoeveel bestanden u registreert.

Aan de slag

Verbind je AI-tool binnen vijf minuten met je DuckDB-gegevens.

Met één MCP-sleutel hebt u toegang tot uw lokale DuckDB-bestanden, alle andere databases en alle API-connectoren in uw Query Streams-account, met een volledig auditlogboek, snelheidslimieten per sleutel en zonder dat er wijzigingen in de firewall nodig zijn. Claude, Cursor, ChatGPT en Grok werken allemaal direct.

Gerelateerde handleidingen: Download de Query Streams Agent. | Databaseconnector instellen | Alle MCP Server-handleidingen | Nova AI tekst-naar-SQL

Categorie: MCP-server

Tags: mcp, claude, cursor, duckdb, analytics-database, developer-tools, embedded-analytics, columnar-database, parquet

Metabeschrijving: Verbind een lokaal DuckDB-bestand met Claude of Cursor via Query Streams MCP. Analysegericht, installatie in 5 minuten.

Geüpdatet op 16 juni 2026

Mogelijk gemaakt door BetterDocs