MCP-integration (AI-værktøjsadgang)

Canopy inkluderer en indbygget MCP-server (Model Context Protocol), der gør det muligt for AI-værktøjer — såsom Claude Desktop, GitHub Copilot, Cursor og VS Code — at forespørge og opdatere dine EA-data direkte. AI-værktøjer kan også uploade artefakter (regneark, BPMN-diagrammer, DrawIO-diagrammer, fritformede dokumenter) og omdanne dem til kort, relationer og diagrammer, der passer til den eksisterende metamodel. Brugere autentificerer sig gennem din eksisterende SSO-udbyder, og hver handling respekterer deres individuelle tilladelser.

Denne funktion er valgfri og starter ikke automatisk. Den kræver, at SSO er konfigureret, at MCP-profilen aktiveres i Docker Compose, og at en admin slår den til i indstillings-UI'et.

Sådan fungerer det

AI Tool (Claude, Copilot, etc.)
    │
    │  MCP protocol (HTTP + SSE)
    ▼
Canopy MCP Server (:8001, internal)
    │
    │  OAuth 2.1 with PKCE
    │  delegates to your SSO provider
    ▼
Canopy Backend (:8000)
    │
    │  Per-user RBAC
    ▼
PostgreSQL

En bruger tilføjer MCP-server-URL'en til sit AI-værktøj.
Ved første forbindelse åbner AI-værktøjet et browservindue til SSO-autentificering.
Efter login udsteder MCP-serveren sit eget access-token (understøttet af brugerens Canopy JWT). Tokenet fornyes proaktivt omkring en time, før det udløber.
AI-værktøjet bruger dette token til alle efterfølgende anmodninger.
Hver forespørgsel går gennem det normale Canopy-tilladelsessystem — brugere ser kun data, de har adgang til.

Forudsætninger

Før du aktiverer MCP, skal du have:

SSO konfigureret og fungerende — MCP delegerer autentificering til din SSO-udbyder (Microsoft Entra ID, Google Workspace, Okta eller generisk OIDC). Se vejledningen Autentificering og SSO.
HTTPS med et offentligt domæne — OAuth-flowet kræver en stabil redirect-URI. Implementér bag en TLS-terminerende reverse proxy (Caddy, Traefik, Cloudflare Tunnel osv.).

Opsætning

Trin 1: Start MCP-tjenesten

MCP-serveren er en opt-in Docker Compose-profil. Tilføj --profile mcp til din opstartskommando:

docker compose --profile mcp up -d

Dette starter en let Python-container (port 8001, kun intern) sammen med backend og frontend. Nginx proxyer /mcp/-anmodninger til den automatisk — hvis containeren ikke kører, får anmodninger et rent 502-svar i stedet for at få edge-proxyen til at gå ned.

Trin 2: Konfigurer miljøvariabler

Tilføj disse til din .env-fil:

CANOPY_PUBLIC_URL=https://your-domain.example.com
MCP_PUBLIC_URL=https://your-domain.example.com/mcp

Variabel	Standard	Beskrivelse
`CANOPY_URL`	`http://backend:8000`	Den interne backend-URL, som MCP-containeren taler med (Docker-servicenavn — sjældent behov for at ændre).
`CANOPY_PUBLIC_URL`	`http://localhost:8920`	Den offentlige URL til din Canopy-instans.
`MCP_PUBLIC_URL`	`http://localhost:8920/mcp`	Den offentlige URL til MCP-serveren (bruges i OAuth-redirect-URI'er og metadata).
`MCP_PORT`	`8001`	Intern port for MCP-containeren (sjældent behov for at ændre).

Trin 3: Tilføj OAuth-redirect-URI'en til din SSO-app

I din SSO-udbyders app-registrering (den samme, du har opsat til Canopy-login), skal du tilføje denne redirect-URI:

https://your-domain.example.com/mcp/oauth/callback

Dette kræves for OAuth-flowet, der autentificerer brugere, når de forbinder fra deres AI-værktøj.

Trin 4: Aktivér MCP i admin-indstillinger

Gå til Indstillinger i admin-området og vælg fanebladet AI.
Rul til afsnittet MCP Integration (AI Tool Access).
Slå kontakten til for at aktivere MCP.
UI'et vil vise MCP-server-URL'en og opsætningsinstruktioner til at dele med dit team.

warning

Kontakten er deaktiveret, hvis SSO ikke er konfigureret. Opsæt SSO først.

Tilslutning af AI-værktøjer

Når MCP er aktiveret, så del MCP-server-URL'en med dit team. Hver bruger tilføjer den til sit AI-værktøj:

Claude Desktop

Åbn Settings > Connectors > Add custom connector.
Indtast MCP-server-URL'en: https://your-domain.example.com/mcp
Klik på Connect — et browservindue åbner for SSO-login.
Efter autentificering kan Claude forespørge og opdatere dine EA-data.

VS Code (GitHub Copilot / Cursor)

Tilføj til dit workspace .vscode/mcp.json:

{
  "servers": {
    "canopy": {
      "type": "http",
      "url": "https://your-domain.example.com/mcp/mcp"
    }
  }
}

Den dobbelte /mcp/mcp er tilsigtet — den første /mcp/ er Nginx-proxystien, den anden er MCP-protokol-endpointet.

Lokal test (stdio-tilstand)

Til lokal udvikling eller test uden SSO/HTTPS kan du køre MCP-serveren i stdio-tilstand — Claude Desktop spawner den direkte som en lokal proces.

1. Installer MCP-serverpakken:

pip install ./mcp-server

2. Tilføj til din Claude Desktop-konfiguration (claude_desktop_config.json):

{
  "mcpServers": {
    "canopy": {
      "command": "python",
      "args": ["-m", "canopy_mcp", "--stdio"],
      "env": {
        "CANOPY_URL": "http://localhost:8000",
        "CANOPY_EMAIL": "your@email.com",
        "CANOPY_PASSWORD": "your-password"
      }
    }
  }
}

I denne tilstand autentificerer serveren sig direkte med e-mail/adgangskode (uden OAuth) og fornyer Canopy-JWT'en automatisk i baggrunden.

Tilgængelige funktioner

MCP-serveren eksponerer 47 værktøjer: 30 læseværktøjer fordelt på ni klynger og 17 skriveværktøjer (13 additive, 4 destruktive). Hvert værktøj bærer ToolAnnotations (readOnlyHint / destructiveHint / idempotentHint), så connectorer som Claude Desktop kan vise, hvor destruktivt et kald er, før en bruger godkender det.

Dry-run-sikkerhed på skrivninger

Hvert skriveværktøj har dry_run=true som standard. I denne tilstand kører backenden hver validator og resolver, bygger den komplette plan og ruller derefter transaktionen tilbage, så intet persisteres. AI-værktøjet returnerer forhåndsvisningen til brugeren; først efter eksplicit bekræftelse bør det kalde værktøjet igen med dry_run=false for at committe. Dette forhindrer, at en entusiastisk agent i stilhed seeder hundredvis af kort ud fra et fejlfortolket regneark.

For større commits findes der en anden spærre: enhver commit over MCP_BATCH_CONFIRMATION_THRESHOLD (standard 20 rækker) skal ekko et engangs-confirm_token, der blev udstedt af den forudgående dry-run. Tokenet har en levetid på 15 minutter. Dette håndhæves to gange — én gang af MCP-wrapperen, før den overhovedet kalder backenden, og igen af selve backenden på commit-endpointet — så en klient, der springer dry-run-trinnet over, ikke kan smugle en stor, ugennemgået batch igennem.

Mutation-batches (revisionsspor)

Hvert skrivekald — dry-run eller ej — åbner en mutation_batches-post, før nogen data røres, og hver hændelse, det udsender (kort oprettet, relation upsertet, kommentar oprettet, …), tagges med det pågældende batch-id samt navnet på det kaldende værktøj og den autentificerede bruger. Værktøjet get_change_history rekonstruerer den fulde hændelse-for-hændelse-diff for en batch ud fra dens id, og rollback_batch kan fortryde en batchs skrivninger (se nedenfor). Det betyder, at enhver MCP-drevet ændring kan spores tilbage til præcis hvem der kørte hvilket værktøj og hvornår — adskilt fra samme handling udført gennem web-UI'et.

Læseværktøjer

Serveren eksponerer 30 læseværktøjer fordelt på ni klynger.

Kort og metamodel

Værktøj	Beskrivelse
`search_cards`	Søg og filtrer kort efter type, status eller fri tekst
`get_card`	Få fulde detaljer for et kort efter UUID
`get_card_relations`	Få alle relationer forbundet til et kort
`get_card_hierarchy`	Få forfædre og børn af et kort
`list_card_types`	Liste over alle korttyper i metamodellen, med felter og konfiguration
`get_relation_types`	Liste over relationstyper, valgfrit filtreret efter korttype
`resolve_card_refs`	Forhåndsvalider navnebaserede kortreferencer (f.eks. "Sales / Customer Mgmt / CRM") før en bulk-import — viser matchede / tvetydige / manglende referencer
`analyze_impact`	Multi-hop konsekvensanalyse — følger relationsgrafen udad fra et kort op til 3 hop, grupperet efter dybde, med valgfrie filtre på relationstype og korttype

Dashboards

Værktøj	Beskrivelse
`get_dashboard`	KPI-dashboard (antal, datakvalitet, godkendelser, aktivitet)
`get_landscape`	Kort af én type grupperet efter en relateret type

GRC — Risikoregister

Værktøj	Beskrivelse
`list_risks`	Pagineret, filterbar EA-risikoliste (TOGAF Phase G)
`get_risk`	Enkelt risikodetalje med tilknyttede kort + revisionsspor
`get_risk_metrics`	KPI'er + 4×4 initial/residual sandsynlighed × impact-matricer
`get_card_risks`	Alle risici, der i øjeblikket er tilknyttet et specifikt kort

GRC — Compliance

Værktøj	Beskrivelse
`list_compliance_findings`	Compliance-fund bundtet efter regulering (EU AI Act, GDPR, NIS2, DORA, SOC 2, ISO 27001)
`get_compliance_overview`	Compliance-scores + per-regulering-statusmatrix + metadata for seneste scanning

Governance og Levering

Værktøj	Beskrivelse
`list_principles`	Publicerede EA-principper (statement, begrundelse, implikationer)
`list_adrs`	Architecture Decision Records, filterbare efter initiativ/kort/status/søgning
`get_adr`	Enkelt ADR med sektioner, tilknyttede kort, relaterede ADR'er, signaturspor
`list_soaws`	Statements of Architecture Work for et initiativ

Rapporter

Værktøj	Beskrivelse
`get_portfolio_report`	Bubble-chart-data for en korttype (funktionel × teknisk fit som standard)
`get_cost_treemap`	Treemap over kortomkostninger, valgfrit grupperet efter en relateret type
`get_capability_heatmap`	Hierarkisk business-capability-heatmap
`get_data_quality_report`	Per-korttype-fuldførelsesopdeling

Kortkontekst

Værktøj	Beskrivelse
`get_card_stakeholders`	Brugere + roller tildelt et kort
`get_card_comments`	Trådede kommentarer på et kort
`get_card_documents`	Dokumentlinks vedhæftet et kort

Diagrammer

Værktøj	Beskrivelse
`list_diagrams`	Liste over fritegnede diagrammer, valgfrit filtreret til ét kort
`get_diagram`	Hent et enkelt diagram efter id, inklusive dets DrawIO-XML

Revision og ændringshistorik

Værktøj	Beskrivelse
`get_change_history`	Slå en mutation-batch op efter id (returnerer batchen + hver hændelse udsendt under den, i rækkefølge), eller gennemse seneste batches efter udførende bruger, værktøjsnavn eller oprindelse (`mcp` / `web` / `api`)

Alle læseværktøjer er bundet af den autentificerede brugers RBAC — en viewer vil simpelthen få en tom liste (eller en 403) for områder, de ikke kan se; intet på MCP-laget skal konfigureres pr. værktøj.

Skriveværktøjer

Serveren eksponerer 17 skriveværktøjer: 13 additive (opret/opdater-handlinger, der ikke destruerer data) og 4 destruktive (kan overskrive eller fjerne data, selvom flere af dem selv er reversible — se noterne nedenfor).

Kort og livscyklus

Værktøj	Annotation	Beskrivelse
`create_cards_bulk`	Additiv	Opret mange kort i ét kald ud fra artefakt-udtrukne rækker (f.eks. regnearksrækker). Understøtter samme-batch-forældrereferencer efter navn med server-side topologisk sortering.
`update_cards_bulk`	Additiv	Opdater mange kort i ét kald — felt-niveau-patches med en per-række før/efter-diff på dry-run. `attributes` er en fuld erstatning pr. række; `strict_attributes=true` afviser ukendte feltnøgler med et rettelseshint.
`transition_card_lifecycle`	Additiv	Flyt et kort gennem godkendelseshandlinger (`approve` / `reject` / `reset`), livscyklusfaser (`phaseIn` / `active` / `phaseOut` / `endOfLife`) eller statusværdier (`ACTIVE` / `PHASING_IN` / `PHASING_OUT` / `END_OF_LIFE` / `ARCHIVED`). Returnerer et `pending`-svar med et UI-dybdelink, hvis den kaldende part mangler tilladelsen, i stedet for at fejle uigenkaldeligt.
`archive_cards`	Destruktiv	Blødsletning (arkivering) af ét eller flere kort, med en cascade-forhåndsvisning på dry-run (børn, forældreløse relationer). Arkiverede kort kan gendannes i 30 dage, inden de auto-renses. Hård/permanent sletning er bevidst ikke eksponeret via MCP.

Relationer og diagrammer

Værktøj	Annotation	Beskrivelse
`upsert_relations_bulk`	Destruktiv	Opret eller slet relationer mellem kort. `action: "delete"` afvises som standard (se rettesnore nedenfor) — det er det, der gør dette værktøj destruktiv-annoteret, selvom oprettelser er det almindelige tilfælde.
`create_diagram`	Additiv	Opret et fritformet DrawIO-diagram, valgfrit tilknyttet eksisterende kort via UUID.
`update_diagram`	Destruktiv	Opdater et eksisterende diagrams XML, navn, beskrivelse eller tilknyttede kort — `drawio_xml` erstatter lærredet ordret.
`import_bpmn`	Additiv	Gem et BPMN 2.0-diagram mod et eksisterende Business Process-kort ved at gennemløbe kladde → indsend → godkend-workflowet. Hvis intet matchende kort findes, returneres en `card_not_found`-fejl, der peger på `create_cards_bulk`, i stedet for stiltiende at oprette et sparsomt kort.

GRC — Risikoregister

Værktøj	Annotation	Beskrivelse
`create_risks`	Additiv	Opret én eller flere risici, valgfrit med tilknytning af berørte kort i samme kald.
`update_risks`	Additiv	Patch eksisterende risici efter id; `linked_card_ids` erstatter sættet af tilknyttede kort, når det angives.

Governance og Levering

Værktøj	Annotation	Beskrivelse
`create_soaw`	Additiv	Opret et Statement of Architecture Work for et initiativ.
`create_adr`	Additiv	Opret et Architecture Decision Record (lander i `draft` som standard).
`update_adr`	Additiv	Opdater titel, sektioner, status eller tilknyttede kort på en eksisterende ADR.
`sign_adr`	Additiv	Signer en ADR. Returnerer et `pending`-svar med et dybdelink, hvis den kaldende part mangler `adr.sign`.

Samarbejde

Værktøj	Annotation	Beskrivelse
`add_card_comment`	Additiv	Skriv en (valgfrit trådet) kommentar på et kort.
`assign_stakeholders`	Additiv	Tildel eller fjern stakeholder-roller på kort. Backenden har ikke et bulk-endpoint til dette, så værktøjet udfører hver operation enkeltvis inden for én mutation-batch.

Revision

Værktøj	Annotation	Beskrivelse
`rollback_batch`	Destruktiv	Fortryd de skrivninger, der er udført under en mutation-batch, ved at gennemløbe dens hændelser i omvendt rækkefølge og anvende det modsatte af hver. Dækker `card.created` / `card.updated` / `card.archived` / `card.restored` / `relation.created` / `relation.upserted`; andre hændelsestyper vises som `unsupported_events` i dry-run-planen. Selve tilbagerulningen registreres som en ny batch, så historikken aldrig slettes. Afvises, hvis en senere batch har rørt de samme entiteter, medmindre `force=true`, hvilket kræver `admin.events`.

Indhold, der gemmes af disse værktøjer (kommentartekster, ADR/SoAW-sektionstekst), behandles som utroværdige data ved senere genlæsning — serveren fortolker det aldrig som instruktioner, den viser det blot.

Typisk artefakt-import-arbejdsgang

Når en bruger deler et regneark med AI-agenten:

Agenten kalder list_card_types og get_relation_types for at forstå metamodellen.
Agenten parser regnearket (i sin egen kontekst, ikke i MCP) og bygger række-dicts.
Valgfrit kalder agenten resolve_card_refs for at tjekke, at eventuelle navnebaserede forældre-/relationsreferencer opløses entydigt.
Agenten kalder create_cards_bulk(cards=…, dry_run=True) og viser forhåndsvisningen til brugeren.
Brugeren bekræfter; agenten kalder igen med dry_run=False (og ekkoer confirm_token, hvis batchen er over bekræftelsesgrænsen) for at committe.
Hvis relationskolonner er til stede, kalder agenten derefter upsert_relations_bulk med den samme dry-run/bekræft-cyklus.

MCP-serveren selv parser aldrig uploadede filer — det kaldende AI-værktøj læser kildeartefaktet (regneark, BPMN-XML, DrawIO-XML, PDF, billede) i sin egen kontekst og sender allerede-strukturerede rækker.

Skriveværktøjs-rettesnore

Forsvar i dybden oven på dry-run, så en LLM-fejltagelse ikke kan forårsage massiv skade:

Per-kald-størrelsesgrænser. MCP-skriveværktøjerne håndhæver en langt mindre grænse end de underliggende Excel-importør-endpoints: 200 kort for create_cards_bulk / update_cards_bulk / archive_cards, 500 operationer for upsert_relations_bulk. Stort nok til enhver realistisk enkelt artefakt-upload, lille nok til, at en dry-run-forhåndsvisning stadig kan gennemses. Selve backend-endpointene accepterer op til 2000/5000 for den legitime Excel-importør i web-UI'et.
Bekræftelsestoken over tærskelværdi. Commits, der rører mere end MCP_BATCH_CONFIRMATION_THRESHOLD rækker (standard 20), skal ekko det confirm_token, der blev udstedt af den forudgående dry-run. Håndhæves af både MCP-wrapperen og backenden.
Ingen relationssletning som standard. upsert_relations_bulk afviser action: "delete"-operationer — for at fjerne relationer, brug web-UI'et, hvor handlingen registreres under brugerens identitet med et eksplicit revisionsspor. Operatører kan tilvælge dette med MCP_ALLOW_RELATION_DELETE=true.
Ingen hård sletning. Værktøjssættet udelader bevidst permanent kortsletning. archive_cards (blødsletning med et 30-dages gendannelsesvindue) og rollback_batch er de eneste måder at fjerne data via MCP på, og begge er dry-run-spærret og destruktiv-annoteret. Ethvert fremtidigt værktøj, der udfører en irreversibel ændring, kræver først en RFC-drøftelse.
Kill switch. MCP_WRITES_ENABLED=false slår alle 17 skriveværktøjer fra uden gendeploy af kode. De 30 læseværktøjer fortsætter med at virke.
Audit origin-tag. Hver backend-anmodning fra MCP-serveren bærer en X-Canopy-Origin: mcp-header (whitelistet server-side til {mcp, web, api} — enhver anden værdi frasorteres). Hændelser udsendt fra disse anmodninger tagges origin: "mcp" i revisions-payloaden, så admins kan filtrere MCP-drevne skrivninger ud af tidslinjen. X-Canopy-Batch-headeren fører det aktuelle mutation-batch-id gennem hvert kald i et enkelt værktøjskald.

Rettesnore-miljøvariablerne på MCP-containeren:

Variabel	Standard	Effekt
`MCP_WRITES_ENABLED`	`true`	Hovedkontakt for skriveværktøjer. `false` → skrivebeskyttet MCP.
`MCP_MAX_CARDS_PER_CALL`	`200`	Hård grænse på rækker pr. kald for `create_cards_bulk`, `update_cards_bulk`, `archive_cards`.
`MCP_MAX_RELATIONS_PER_CALL`	`500`	Hård grænse på `upsert_relations_bulk`-operationer pr. anmodning.
`MCP_ALLOW_RELATION_DELETE`	`false`	Når `true`, accepterer `upsert_relations_bulk` `action: "delete"`-operationer.
`MCP_BATCH_CONFIRMATION_THRESHOLD`	`20`	Rækkeantal, over hvilket en commit skal ekko et `confirm_token` fra en forudgående dry-run.
`MCP_REQUIRE_DRYRUN_FIRST`	`true`	Når `true`, afvises en commit over tærskelværdien uden en matchende forudgående dry-run i samme session. Operatører kan deaktivere dette for betroede automatiseringspipelines.

Ressourcer

URI	Beskrivelse
`turbo-ea://types`	Alle korttyper i metamodellen
`turbo-ea://relation-types`	Alle relationstyper
`turbo-ea://dashboard`	Dashboard-KPI'er og oversigtsstatistik

Guidede prompts

Prompt	Beskrivelse
`analyze_landscape`	Flertrinsanalyse: dashboard-oversigt, typer, relationer
`find_card`	Søg efter et kort efter navn, få detaljer og relationer
`explore_dependencies`	Kortlæg, hvad et kort afhænger af, og hvad der afhænger af det

Tilladelser

Rolle	Adgang
Admin	Konfigurer MCP-indstillinger (`admin.mcp`-tilladelse). Fuld læse + skrive gennem MCP.
Alle autentificerede brugere	Læseadgang styres af deres eksisterende RBAC. Skriveværktøjer kræver den matchende backend-tilladelse for den handling, de udfører.

Dataadgang gennem MCP — læse eller skrive — følger den samme RBAC-model som web-UI'et. Hvis en bruger ikke kan oprette kort i lager-UI'et, kan de heller ikke oprette dem gennem MCP; der er ingen separate MCP-specifikke datatilladelser. Udvalgte tilladelser pr. værktøj:

Tilladelse	Styrer
`inventory.create`	`create_cards_bulk`
`inventory.edit`	`update_cards_bulk`, livscyklus-/statusovergange via `transition_card_lifecycle`
`inventory.approval_status`	Godkendelsesovergange (`approve` / `reject` / `reset`) via `transition_card_lifecycle`
`inventory.archive`	`archive_cards`
`relations.manage`	`upsert_relations_bulk`
`diagrams.manage`	`create_diagram`, `update_diagram`
`bpm.edit`	`import_bpmn` (kladde); publicering kræver derudover `card.approval_status` på processen, som opnås via stakeholder-rollen `process_owner`, admin eller bpm_admin
`risks.manage`	`create_risks`, `update_risks`
`comments.create`	`add_card_comment`
`stakeholders.manage`	`assign_stakeholders`
`soaw.create`	`create_soaw`
`adr.create`	`create_adr`, `update_adr`
`adr.sign`	`sign_adr`
`admin.events`	`rollback_batch(force=True)` — for at overstyre en tilbagerulningskonflikt med en senere batch

Tilladelsen admin.mcp styrer, hvem der kan administrere MCP-indstillinger. Den er kun tilgængelig for Admin-rollen som standard. Brugerdefinerede roller kan tildeles denne tilladelse gennem Roller-administrationssiden.

Flere skriveværktøjer degraderer elegant i stedet for at fejle hårdt, når den kaldende part mangler en tilladelse: transition_card_lifecycle og sign_adr returnerer et pending-svar med et dybdelink ind i web-UI'et, så et menneske med den rette tilladelse kan fuldføre handlingen der.

Sikkerhed

SSO-delegeret autentificering: Brugere autentificerer sig via deres virksomheds SSO-udbyder. MCP-serveren ser eller gemmer aldrig adgangskoder (i HTTP-tilstand).
OAuth 2.1 med PKCE: Autentificeringsflowet bruger Proof Key for Code Exchange (S256) for at forhindre autorisationskode-aflytning.
Per-bruger RBAC: Hver MCP-forespørgsel — læse eller skrive — kører med den autentificerede brugers tilladelser. Ingen delte servicekonti.
Dry-run som standard på skrivninger: Skriveværktøjer har som standard en valider-og-tilbagerul-forhåndsvisning. AI-værktøjet skal eksplicit kalde igen med dry_run=false, før noget persisteres, og hver ændring revideres under brugerens identitet som en del af en mutation-batch.
Bekræftelsestoken-spærre på store commits: Commits over den konfigurerbare rækketærskel kræver et token udstedt af en forudgående dry-run, tjekket uafhængigt af både MCP-wrapperen og backenden.
Fuldt revisionsspor med tilbagerulning: get_change_history rekonstruerer enhver batchs diff ud fra dens id; rollback_batch kan fortryde en batchs understøttede hændelsestyper, og selve tilbagerulningen registreres som en ny, revisionssporbar batch.
Ingen filparsing i MCP: MCP-serveren selv accepterer ikke PDF'er, Excel-filer, billeder eller andre binære artefakter. Det kaldende AI-værktøj parser dem i sin egen kontekst og sender strukturerede rækker. Dette holder angrebsfladen smal og undgår at eksponere serveren for misdannet binær input.
Ingen hård sletning via MCP: Permanent kortsletning eksponeres ikke som et værktøj. De eneste sletteveje er archive_cards (30-dages gendannelig blødsletning) og rollback_batch.
Token-rotation: Access-tokens udløber efter 1 time og fornyes proaktivt. Refresh-tokens varer 30 dage. Autorisationskoder er engangsbrug og udløber efter 10 minutter.
Kun intern port: MCP-containeren eksponerer port 8001 kun på det interne Docker-netværk. Al ekstern adgang går gennem Nginx reverse proxy.
Enkelt-instans-tokenlager: OAuth-tokens holdes i hukommelsen på MCP-containeren. Hvis du kører flere replikaer bag en load balancer, skal du pinne sessioner til én instans eller forvente, at brugere skal genautentificere efter en failover — tokens deles ikke på tværs af replikaer.

Fejlfinding

Problem	Løsning
MCP-kontakten er deaktiveret i indstillinger	SSO skal konfigureres først. Gå til fanebladet Indstillinger > Autentificering og opsæt en SSO-udbyder.
"host not found" i Nginx-logs	MCP-tjenesten kører ikke. Start den med `docker compose --profile mcp up -d`. Nginx-konfigurationen håndterer dette elegant (502-svar, intet nedbrud).
OAuth-callback fejler	Bekræft, at du har tilføjet `https://your-domain.example.com/mcp/oauth/callback` som en redirect-URI i din SSO-app-registrering.
AI-værktøjet kan ikke oprette forbindelse	Tjek, at `MCP_PUBLIC_URL` matcher den URL, der er tilgængelig fra brugerens maskine. Sørg for, at HTTPS virker.
Brugeren får tomme resultater	MCP respekterer RBAC-tilladelser. Hvis en bruger har begrænset adgang, vil de kun se de kort, deres rolle tillader.
Skriveværktøj returnerer `writes_disabled`	`MCP_WRITES_ENABLED=false` på denne implementering. Læseværktøjer virker stadig; bed en operatør om at genaktivere skrivninger, hvis nødvendigt.
Commit afvist med `confirm_token_required`	Batchen er over `MCP_BATCH_CONFIRMATION_THRESHOLD` rækker. Kør igen med `dry_run=true` først, og send derefter det returnerede `confirm_token` tilbage på commit-kaldet.
Forbindelse droppes efter 1 time	AI-værktøjet bør håndtere token-fornyelse automatisk. Hvis ikke, genopret forbindelse.

Sådan fungerer det​

Forudsætninger​

Opsætning​

Trin 1: Start MCP-tjenesten​

Trin 2: Konfigurer miljøvariabler​

Trin 3: Tilføj OAuth-redirect-URI'en til din SSO-app​

Trin 4: Aktivér MCP i admin-indstillinger​

Tilslutning af AI-værktøjer​

Claude Desktop​

VS Code (GitHub Copilot / Cursor)​

Lokal test (stdio-tilstand)​

Tilgængelige funktioner​

Dry-run-sikkerhed på skrivninger​

Mutation-batches (revisionsspor)​

Læseværktøjer​

Skriveværktøjer​

Typisk artefakt-import-arbejdsgang​

Skriveværktøjs-rettesnore​

Ressourcer​

Guidede prompts​

Tilladelser​

Sikkerhed​

Fejlfinding​