Trinn‑for‑trinn: Bygg en YouTube-forskningsagent med Claude Code
Hvis du noen gang har brukt en ettermiddag på å forsvinne ned i YouTube‑kaninhullet, bare for å glemme hvilke videoer som var verdt å lagre, er du ikke alene. Tenk deg nå en utrettelig assistent som kan finne de beste videoene, trekke ut sammendrag, hente viktige sitater, tidsstemple innsikter og returnere kilder på forespørsel – raskt. Det er akkurat det en YouTube-forskningsagent kan gjøre. I denne trinn‑for‑trinn‑guiden skal vi bygge en praktisk YouTube-forskningsagent med Claude Code, designet for skapere, analytikere, studenter og besatte elever som ønsker signal fremfor støy.
Vi tar en praktisk og direkte rute: arkitektur, kode, ledetekster og sikkerhetsmekanismer. Underveis vil vi ta meningsfulle valg som du kan endre senere. Innen slutten vil du ha en fungerende agent som kan søke på YouTube, samle transkripsjoner, resonnere på tvers av flere videoer og produsere rene forskningsrapporter.
Hva vi bygger (og hvorfor det er viktig)
- Mål: En YouTube-forskningsagent som kan:
- Søke på YouTube etter spørring
- Rangere resultater etter relevans/engasjement
- Hente transkripsjoner (automatiske bildetekster eller tredjeparts)
- Dele opp og legge inn innhold for gjenfinning
- Bruke Claude Code til å syntetisere innsikter fra flere videoer
- Output strukturerte notater: sammendrag, påstander, tidsstempler, sitater og henvisninger
- Primært nøkkelord: "Building a YouTube research agent with Claude Code"
- Format: Trinn‑for‑trinn‑veiledning med kjørbar kode og ledetekster
- Outputs: Markdown-forskningsrapport + JSON for programmatisk bruk
Hvorfor det er viktig: YouTube er den største offentlige kunnskapsbasen for samtaler, leksjoner, demoer og debatter. Men det er mye støy. Å bygge en YouTube-forskningsagent med Claude Code gir deg en fordel: du kan samle innsikter på tvers av dusinvis av videoer på minutter, ikke timer.
Arkitektur i et overblikk
Vi holder den første versjonen enkel og robust.
- Inputs: en forskningsspørring (f.eks. "LLM agent architectures 2025"), valgfrie begrensninger (datoperiode, kanal, varighet)
- YouTube Search: YouTube Data API v3 (eller SerpAPI fallback)
- Transkripsjoner: YouTube Transcript API; fallback til ASR (f.eks. Whisper) når utilgjengelig
- Oppdeling: Setningsbevisst segmentering (ca. 800–1200 tokens)
- Innbygginger: Bruk en lokal eller hostet innbyggingsmodell (f.eks.
text-embedding-3-large, nomic-embed-text, eller bge-large)
- Vektorlager: Lokal
FAISS for hastighet; kan byttes til Pinecone, Weaviate, eller Qdrant
- Resonnering: Claude Code for orkestrering, verktøybruk, syntese og kodeutførelse inne i en kontrollert loop
- Outputs: Markdown-rapport + JSON-indeks med henvisninger, tidsstempler og poengsummer
Dataflyt: Spørring → Søk → Hent metadata → Transkripsjon → Oppdeling → Bygg inn → Hent topp‑K → Claude Code-syntese → Rapport.
Forutsetninger og oppsett
- API-nøkler:
YOUTUBE_API_KEY, ANTHROPIC_API_KEY (for Claude Code)
- Valgfritt:
OPENAI_API_KEY eller lokale innbygginger
google-api-python-client, youtube-transcript-api
faiss-cpu, numpy, pandas, tiktoken (eller sentencepiece)
requests, pydantic, tenacity
pip install google-api-python-client youtube-transcript-api faiss-cpu numpy pandas requests pydantic tenacity anthropic tiktoken
Miljøvariabler:
export YOUTUBE_API_KEY=YOUR_YT_KEY
export ANTHROPIC_API_KEY=YOUR_ANTHROPIC_KEY
Trinn 1: YouTube-søk med filtre
Vi skal søke på YouTube og returnere strukturerte metadata: tittel, kanal, publiseringsdato, varighet, visninger (hvis tilgjengelig) og videoId.
# file: yt_search.py
from googleapiclient.discovery import build
import os
YOUTUBE_API_KEY = os.environ — channel, date\n\n"
"---\n"
"JSON schema: {\"claims\":[{\"claim\":str,\"support\":[{\"video_id\":str,\"start\":float,\"end\":float}]}]}\n"
)
def call_claude(goal: str, passages: list[dict]):
passages_str = "\n\n".join(
f"[rank {p['rank']} | score {p['score']:.3f}] (vID={p.get('video_id','?')}, {p.get('start',0):.1f}-{p.get('end',0):.1f})\n{p['text']}"
for p in passages
)
msg = client.messages.create(
model="claude-3-5-sonnet-20240620",
max_tokens=1800,
temperature=0.2,
system=SYSTEM_PROMPT,
messages=[
{"role": "user", "content": USER_TEMPLATE.format(goal=goal, passages=passages_str)}
])
return msg.content[0].text
Prompt-tips når du bygger en YouTube-forskningsagent med Claude Code:
- Be om strukturerte utdata i både menneskelig lesbare og maskinlesbare formater
- Håndhev tidsstemplede sitater
- Oppmuntre til usikkerhetsavsløringer og motsetninger
Trinn 6: Sette alt sammen
La oss koble opp spørring → søk → transkripsjoner → chunks → embeddings → retrieve → synthesize.
# file: run_agent.py
from yt_search import search_youtube
from transcripts import fetch_transcript
from chunking import transcript_to_docs
from embeddings import VectorStore
from orchestrator import call_claude
from datetime import datetime
def build_corpus(query: str, max_videos=8):
results = search_youtube(query, max_results=max_videos)
corpus_docs = []
for r in results:
tx = fetch_transcript(r["video_id"]) or []
if not tx:
continue
docs = transcript_to_docs(tx)
for d in docs:
d.update({
"video_id": r["video_id"],
"title": r["title"],
"channel": r["channel"],
"url": r["url"],
})
corpus_docs.extend(docs)
return corpus_docs
def research(query: str, k=12):
corpus = build_corpus(query)
if not corpus:
return "No transcripts available."
vs = VectorStore
vs.add(corpus)
passages = vs.search(query, k=k)
md = call_claude(query, passages)
timestamp = datetime.utcnow.isoformat
return f"<!-- generated {timestamp} UTC -->\n\n" + md
if __name__ == "__main__":
print(research("LLM agents for YouTube research"))
Denne basisversjonen av en YouTube-forskningsagent med Claude Code vil søke, hente og syntetisere innsikter fra flere videoer med sitater. Oppgrader innbyggingene og legg til hurtigbuffer for å gjøre den produksjonsklar.
Syv oppgraderinger for å gjøre den flott
- Bedre innbygginger og hybridsøk
- Bytt inn høykvalitetsinnbygginger og legg til BM25-nøkkelordsøk. Hybrid gir mer tilbakekalling på nisjetermer og bedre presisjon på abstrakte emner.
- Utvid verktøy for rikere metadata
- Hent kommentarer, liker/misliker-forhold og kanalautoritet. Legg til en re‑ranker (cross‑encoder) for topp 100 kandidater.
- Fler‑trinns forskningsplanlegging
- Bruk Claude Code til å foreslå en forskningsplan: underspørsmål, hypoteser og dekningssjekker. Utfør iterativt til dekningsgrenser er nådd.
- For hver påstand, logg støttende og motstridende utdrag. Presenter begge i rapporter; legg til konfidenspoengsummer.
- Strategier for lange videoer
- Bruk scenedeteksjon via undertekster eller Whisper-ordtider. Oppsummer per‑seksjon før global syntese for å unngå kontekstutvanning.
- Lagre transkripsjoner, innbygginger og rapporter per spørring. Bruk på nytt når brukere justerer filtre. Legg til deduplisering etter video‑ID.
- Eksportformater og levering
- Eksporter Markdown, PDF og JSON. E-post eller Slack-levering. Gjengi tidsstempler som klikkbare
?t=mmss lenker.
Prompts du kan gjenbruke
Bruk disse malene mens du bygger en YouTube-forskningsagent med Claude Code.
System: Du er en omhyggelig forskningsagent. Syntetiser på tvers av flere YouTube-transkripsjoner. Sitér inline med [vID @ mm:ss], og inkluder en Kilder-seksjon med URL-er. Returner både en Markdown-rapport og en JSON-nyttelast av påstander med tidsstemplet støtte.
User: Research goal: {topic}
Constraints: focus on {audience or scope}; prefer sources within {date range}; include disagreements.
Candidate passages (ranked):
{retrieved_passages}
Output: Summary → Key Insights (bullets) → Notable Quotes (with timestamps) → Contradictions & Gaps → Sources. Then JSON {"claims": ...}
Sikkerhetsmekanismer og etikk
- Respekter skaperrettigheter: Lenk til de originale videoene og unngå å publisere store ordrette transkripsjoner.
- Vær transparent: Vis hvor påstander kommer fra ved hjelp av tidsstempler og video‑ID‑er.
- Unngå over‑oppsummering: Bevar nyanser; flagg når bildetekster er automatisk generert og sannsynligvis støyende.
- Håndter sensitive emner nøye: Fremhev usikkerhet og søk ulike kilder.
Feilsøking: Vanlige problemer og rettelser
- "Ingen transkripsjon funnet"
- Fallback til Whisper; prøv forskjellige språk; sjekk om videoen er region‑blokkert.
- Oppgrader innbygginger; legg til BM25; øk chunk-overlap; parameter‑tune topp‑K.
- Tving strengt sitatskjema; straff ustøttede påstander; krev eksakte tidsstempler tilstede i hentede chunks.
- Cache aggressivt; reduser
max_results; batchforespørsler; legg til back‑off med tenacity.
- Oppsummer per‑seksjon; begrense maks tokens; bruk planleggingsprompter med eksplisitt disposisjon.
Måling av kvalitet
- Precision@K av hentede chunks vs. et merket sett
- Faithfulness rate: andel påstander med verifiserbar tidsstemplet støtte
- Dekning: antall unike relevante videoer sitert
- Latency: tid fra spørring til rapport
Eksempel: Undersøke "Vector Databases Explained"
- Spørring: "vector databases explained for developers 2025"
- Filtre: videoer etter 2023, varighet 6–30 minutter
- Utfall: Agenten siterer 6 videoer, fremhever trade‑offs mellom HNSW vs. IVF‑PQ, diskuterer kostnad/tilbakekalling og lenker til benchmarks. Contradictions-seksjonen sammenligner leverandørpåstander vs. open‑source-resultater.
Forresten: Automatisere dette inne i arbeidsflyten din
Hvis du jobber på tvers av dokumenter og kode, er det verdt å automatisere den siste milen. En liten CLI kan kjøre nattlige spørringer og slippe Markdown-rapporter inn i kunnskapsbasen din. Du kan også koble den inn i problemmaler for sprintforskning.
Verdt å merke seg: hvis arbeidsflyten din allerede finnes i en nettlesersidefelt eller AI-assistent, kan verktøy som Sider.AI effektivisere forskningssløyfen – velg et emne, kjør et søk, fang transkripsjoner og utkast et Claude‑drevet sammendrag rett der du jobber. Dette kan spare kontekstbytte og gjøre det å bygge en YouTube-forskningsagent med Claude Code enda mer praktisk for team. Viktige takeaways
- Å bygge en YouTube-forskningsagent med Claude Code er en måte med høy utnyttelse for å gjøre videoer om til handlingsrettede rapporter.
- Den minimale stacken: YouTube API + transkripsjoner + chunking + embeddings + FAISS + Claude synthesis.
- Oppgraderingsstier: hybridsøk, re‑ranking, planleggingssløyfer og streng sitatsporing.
- Start enkelt, mål faithfulness og iterer mot pålitelighet.
Neste steg
- Implementer en ekte embedding-modell og hybrid henting
- Legg til et re‑ranking-trinn og kvalitetsmetrikker
- Opprett en planlagt jobb for å oppdatere emner ukentlig
- Pakk som en CLI og et lett web-UI
FAQ
Q1:How do I start building a YouTube research agent with Claude Code?
Begin with YouTube search, fetch transcripts, chunk content, embed into a vector store, and use Claude Code to synthesize results. The guide above provides step-by-step code to assemble a working pipeline.
Q2:What libraries are best for a YouTube research agent?
Use the YouTube Data API for search, youtube-transcript-api for captions, FAISS for vector search, and the Anthropic SDK to call Claude Code. You can swap embeddings with OpenAI, Nomic, or BGE.
Q3:How do I ensure accurate citations and timestamps?
Keep start/end timestamps during chunking and require Claude Code to cite [video_id @ mm:ss]. Validate that cited timestamps exist in retrieved chunks before publishing.
Q4:Can I use this agent for private or unlisted videos?
Yes, if you have access and can fetch transcripts or run local ASR (e.g., Whisper). Always respect permissions and avoid distributing copyrighted content.
Q5:How can I scale this YouTube research agent for teams?
Add caching, a shared vector store, job queues, and scheduled runs. Integrate with Slack or a wiki, and consider a browser-based assistant like Sider.AI to streamline researcher workflows.