Handledning för Claude Code Connector: Triagera GitHub-repon på 20 minuter

I den här handledningen visar jag hur du kopplar Claude Code till GitHub med en Claude-connector (byggd på Model Context Protocol) och använder den för att triagera ett open source-repo från början till slut. 

Arbetsflödet klonar ingenting, behöver inget vektorlager och rör inte en enda rad i målrepon. I stället läser Claude Code ärenden via connectorn och skriver artefakter till ditt lokala filsystem som du granskar innan du bestämmer vad (om något) som ska publiceras.

När du är klar med handledningen har du:

• En fungerande Claude Code- och GitHub MCP-uppsättning med en skrivskyddad token,
• Några återanvändbara promptar som du kan rikta mot valfritt publikt repo,
• En komplett triageartefakt för langchain-ai/langchain att jämföra med.

Vad är Claude Code GitHub Connector (MCP)?

Claude Code är Anthropics terminalbaserade kodningsagent. 

Redan från start har den åtkomst till ditt filsystem, skal och git. Claude Code Connectors utökar den så att den når extern kontext, till exempel GitHub-ärenden, Linear-ärenden, Slack-meddelanden, Postgres-frågor och så vidare, som terminalen inte kan nå på egen hand.

Connector-protokollet heter MCP (Model Context Protocol), som är en öppen standard för att exponera verktyg och data för LLM-agenter. 

Anthropic underhåller en katalog över färdiga connectorer, och du kan också skriva egna eller koppla upp dig mot tredjeparts MCP-servrar.

För den här handledningen använder vi den officiella GitHub MCP-servern, som körs lokalt via Docker. Några grundidéer bakom uppsättningen:

• Körs som en lokal Docker-container utan molnmäklare, så autentiseringsuppgifterna stannar på din dator.
• Autentiseras med en standardiserad personlig åtkomsttoken (PAT) för GitHub, så ingen OAuth-appregistrering behövs.
• Den stöder avgränsade behörigheter, som en oavgränsad PAT, vilket ger skrivskyddad åtkomst till publika repon, så skrivningar är omöjliga på GitHubs API-nivå.
• Den exponeras för Claude Code via kommandot claude mcp add, därefter är verktygen tillgängliga i varje session.

Open source-triagering innebär mycket läsning, mycket omdöme och är billigt att ha fel om. 

Att läsa 50 ärenden och klustra dem är tidskrävande för en människa, men passar bra för en modell som kan hålla allt i kontext samtidigt. 

Dessutom skriver vi utdata som lokala filer först; ett dåligt kluster eller ett klumpigt utkast kostar ingenting, och du kan fånga det vid granskningen.

Handledning för Claude Code GitHub Connector: Bygg en triage för langchain-ai/langchain

I det här avsnittet sätter vi upp GitHub-connectorn i Claude Code och kör fyra triage-promptar mot langchain-ai/langchain. Det är ett stort ML-repo med en genuint rörig ärendehantering. På en övergripande nivå bygger vi detta:

• Koppla Claude Code till GitHub via den officiella MCP-servern som körs i Docker,
• Använd en PAT med noll scope så att connectorn är skrivskyddad från början,
• Kör triage-promptar som sparar resultat till lokala filer,
• Granska utdata, inklusive fall där Claude vägrade klustra ärenden som dubbletter.

Låt oss bygga det steg för steg.

Steg 1: Installera förutsättningar för Claude Code och Docker

Innan vi sätter upp connectorn behöver du tre saker:

• Claude Code: Du kan installera det från Anthropics officiella installationsguide,
• Docker Desktop: den officiella GitHub MCP-servern körs i en container, så Docker måste vara installerat och igång,
• Ett GitHub-konto: Det behövs för att generera PAT i nästa steg.

När du har alla förutsättningar på plats, verifiera att Docker körs:

docker info | head -5

Om Docker inte är installerat eller om daemonen inte är igång, ser du felet "Cannot connect to the Docker daemon". På macOS startar du Docker Desktop med:

open -a Docker

Docker Desktop tar 15–60 sekunder att bli helt redo, och docker info kommer fortsätta ge fel under det fönstret. I stället för att hålla koll manuellt kan du använda en liten vänt-one-liner som pollar tills daemonen är uppe:

tills 

docker info >/dev/null 2>&1; do sleep 2; echo "waiting..."; done && echo "Docker ready"

När den skriver ut Docker ready kan du gå vidare.

Steg 2: Skapa en skrivskyddad GitHub-token

När Docker är uppsatt, gå till github.com/settings/tokens och generera en ny klassisk token.

Obs: Lämna alla scope omarkerade. En oavgränsad token kan fortfarande läsa publika repon via GitHubs API, vilket är allt vår agent behöver. Utan några valda scope kan tokenen inte skriva, ändra eller ta bort något på GitHub, oavsett vad vi ber Claude göra. Detta är en hård garanti som upprätthålls på GitHubs sida, inte ett löfte vi ger om agentens beteende.

Kopiera och spara tokenen direkt efter generering, exportera den sedan i ditt skal:

export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_your_token_here"

Om du redan är inne i en Claude Code-session kanske du frestas att använda prefixet ! för att köra exportkommandot direkt i ditt skal (t.ex. ! export GITHUB_PERSONAL_ACCESS_TOKEN="..."). 

Men eftersom ! startar ett temporärt underskal kommer variabeln försvinna i samma ögonblick som kommandot är klart, och Claude kommer inte se den.

För att sätta tokenen säkert utan att klistra in den i modellprompten har du två alternativ:

1. Skriv /exit för att lämna Claude, kör exportkommandot i din vanliga terminal och starta om claude.
2. Eller spara tokenen i en lokal .env-fil i din arbetskatalog, som Claude Code automatiskt läser vid start.

Verifiera att båda förutsättningarna är redo utan att ekoa själva tokenen:

docker info | head -3
echo "Token set: ${GITHUB_PERSONAL_ACCESS_TOKEN:+yes}"

Det andra kommandot skriver ut Token set: yes om variabeln finns och Token set: (inget efter kolon) om den är tom. 

Detta är säkrare än att ekoa tokenen direkt eftersom det inte finns någon risk att den hamnar i din skalhistorik i klartext.

Steg 3: Registrera GitHub-connectorn med Claude Code

Den officiella GitHub MCP-servern levereras som en Docker-image. 

Vi registrerar den hos Claude Code med claude mcp add:

claude mcp add github \
  -e GITHUB_PERSONAL_ACCESS_TOKEN=$GITHUB_PERSONAL_ACCESS_TOKEN \
  -- docker run -i --rm \
  -e GITHUB_PERSONAL_ACCESS_TOKEN \
  ghcr.io/github/github-mcp-server

De två -e-flaggorna är inget stavfel här:

• Den första -e (före --) sätter en miljövariabel för MCP-processen som Claude Code startar,
• Den andra -e (inne i argumenten till docker run) säger åt Docker att vidarebefordra den variabeln in i containern.

Om du missar någon av dem och containern startar med en tom token misslyckas autentiseringen mot GitHub-API:t.

För att verifiera att connectorn är registrerad:

claude mcp list

Du bör se:

github — docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server —  Connected

Om du ser Failed to connect är de två vanligaste orsakerna att Docker inte körs eller att GITHUB_PERSONAL_ACCESS_TOKEN inte är exporterad i samma skal där du körde claude mcp add.

Steg 4: Rimlighetskolla anslutningen

Nu är vår GitHub-token satt. Nästa steg är att skapa en arbetskatalog och öppna Claude Code CLI:

mkdir demo && cd demo
claude

Kommandot claude startar en interaktiv session i den aktuella katalogen. 

Alla filer som Claude skriver under triagen hamnar här. 

Ställ sedan en enkel skrivskyddad fråga för att bekräfta att connectorn används:

Using the GitHub MCP connector, fetch the 5 most recently updated open issues in langchain-ai/langchain. Just list titles and numbers.

Första gången Claude Code använder ett GitHub-verktyg ber den om godkännande. 

Godkänn skrivskyddade verktyg som list_issues, get_issue, search_issues osv. 

Om Claude faller tillbaka till curl mot GitHubs publika API i stället för att använda MCP-verktyg, är connectorn inte inläst. Avsluta då sessionen och starta om den.

En lyckad körning returnerar något i stil med:

När du ser riktiga ärendenummer komma tillbaka via MCP är vi redo att köra den faktiska triagen.

Steg 5: Skapa en backlogg-sammanfattning

Uppvärmningsuppgiften är helt skrivskyddad. Nu vill vi ha en karta över vad som finns i ärendehanteringen innan vi gör något annat.

Prompt:
Using the GitHub MCP connector, pull the 50 most recently updated open issues from langchain-ai/langchain. 
Read their titles, bodies, and labels. Group them by likely area — bugs, feature requests, documentation, questions, and "needs more info." 
For each group, give me a count and 3-5 representative issue numbers with a one-line reason. Save as backlog-summary.md in the current directory.

Claude Code hämtar ärendena via connectorn, läser igenom dem och skriver en markdown-fil som grupperar dem efter område med representativa ärendenummer. Den här filen är användbar i sig: en underhållare kan skumma den på 60 sekunder och veta vilken sorts vecka som väntar.

Steg 6: Flagga dubblettkandidater

Dubblettdetektion är där en agent gör mest nytta. 

Att läsa 50 ärenden från början till slut och klustra efter underliggande problem är tidskrävande för en människa, men en modell kan hålla alla i kontext och upptäcka överlapp som en nyckelordsökning missar.

Prompt:
From the same 50 issues you already pulled, identify clusters of likely duplicates: issues describing the same underlying problem, even if titles differ. For each cluster, output issue numbers, a one-sentence shared-problem description, and confidence (high/medium/low). Save as duplicate-candidates.md.

Här är vad Claude faktiskt producerade i min körning:

Det mest intressanta i detta utdata är kluster 2 till 4. 

En naiv nyckelordsbaserad dubblettdetektor hade stängt alla fyra klustren som dubbletter. 

Claude vägrade uttryckligen att kalla dem dubbletter. 

Den flaggade dem som komponentkluster inom samma delsystem, med distinkta grundorsaker, och berättade vilka som faktiskt skulle stängas (bara kluster 1) respektive vilka som skulle triageras gemensamt men hållas öppna.

Det är beteendet du vill ha från en noggrann mänsklig triagerare, och det är precis därför mönstret lokala filer + granskning är värt extra steget. 

Om vi hade kopplat detta direkt till GitHubs API och autostängt allt som Claude flaggade hade vi stängt tre riktiga buggar.

Steg 7: Granska, och bestäm sedan vad som ska postas

Detta är hela poängen med mönstret med lokala filer. 

Innan något rör GitHub, kontrollera varje .md-fil som Claude sparat och se om grupperingarna stämmer med din intuition. 

Ser högkonfidensklustren faktiskt ut som dubbletter? Läs 2–3 utkast till svar och kontrollera om de låter som du.

Om du faktiskt vill posta kommentarerna eller applicera etiketter har du två alternativ:

• Manuellt: Du kan klistra in utkasten i GitHub själv. För en engångstriage på någon annans repo är detta okej och ofta rätt val.
• Auktorisera skrivningar på ett repo du äger:  Generera en separat PAT med repo-scope, lägg till den som en egen connectorpost (t.ex. github-write) och kör om promptarna där du ber Claude att applicera etiketter och posta kommentarer. Claude Code ber om godkännande för varje skrivverktyg första gången det används.

Det viktigaste säkerhetsdraget för skrivvägen är att hålla läs- och skrivtoken åtskilda. 

Slutsats

I den här handledningen visade jag hur du kopplar Claude Code till GitHub via MCP och använder det för att triagera ett verkligt open source-repo från början till slut. 

I stället för att bygga en egen GitHub-bot eller koppla in webhooks läser arbetsflödet ärenden via den officiella GitHub MCP-servern, skriver fyra triageartefakter som lokala filer och låter dig granska allt innan du bestämmer vad som ska postas.

Den bredare lärdomen är att connectorer förvandlar Claude Code från en kodningsagent till ett verktyg som kan läsa dina verktyg och förbereda arbete för dig att granska. 

Standardläget bör vara att hålla det arbetet lokalt tills du har sett det, och när du väl litar på mönstret kan du selektivt låta agenten agera där kostnaden för ett misstag är låg.

Härifrån kan du utöka projektet på flera sätt:

• Lägg till skrivkapabla connectorer på repon du äger så att etiketter och kommentarer appliceras automatiskt efter granskning,
• Kedja in Linear- eller Slack-connectorer för att synka triagebeslut till teamets arbetsflöde,
• Gör om promptarna till ett schemalagt CI-jobb som skapar en veckovis triage-PR,
• Eller generalisera ovanstående promptar till ett återanvändbart Claude Code-snedstreckskommando som fungerar på valfri repo-URL.