Veiledning for å bygge ADK-agenter med kraftige ferdigheter

Home » Python » Veiledning for å bygge ADK-agenter med kraftige ferdigheter

Intelligente agenter bygget med et Agent Development Kit (ADK) blir raskt ryggraden i moderne AI-drevne applikasjoner., som går langt utover enkeltstående chatboter som bare svarer på spørsmål. Med riktig ferdighetssystem kan disse agentene resonnere, planlegge, kalle verktøy, samarbeide med andre agenter og til og med forbedre sitt eget arbeid i løkker, samtidig som de holder tokenbruk og latens under kontroll takket være progressive avsløringsteknikker.

I denne grundige veiledningen vil du gå gjennom hvordan du designer, strukturerer og orkestrerer ADK-agenter med ferdigheter, fra grunnleggende arbeidsflyter med én agent til arbeidsflyter med flere agenter som kjører i sekvens, i løkker og parallelt. Du vil også se hvordan virkelige stabler som Googles ADK-kodelaboratorier, fellesskapsferdigheter og orkestreringsrammeverk som AgentKit 2.0 bruker mønstre som Router, SequentialAgent, LoopAgent og ParallelAgent, samt hvordan selskaper som Q2BSTUDIO kombinerer dette med skyplattformer og cybersikkerhet for å levere produksjonsklare systemer.

Hvorfor ADK-agenter med ferdigheter er viktige for moderne programvareteam

Eksplosjonen av AI i programvareutvikling har presset team til å lete etter måter å innkapsle ekspertise og arbeidsflyter i gjenbrukbare, komponerbare enheter.ADK-er svarer på dette behovet ved å la deg pakke atferd, domeneregler og verktøy inn i agenter som kan gjenbrukes på tvers av prosjekter, team og til og med produkter.

Kjernen i denne tilnærmingen er agentferdigheter, som er selvstendige kunnskapsmoduler som en agent kan laste inn på forespørsel. I stedet for å dumpe alle retningslinjer og regler i én massiv ledetekst, bruker ferdigheter en progressiv avsløring arkitektur: instruksjoner, ressurser og skript vises bare når det er nødvendig, noe som holder konteksten slank og ytelsen høy selv når du har hundrevis av ferdigheter installert.

Denne effektiviteten er avgjørende i en verden der tokenbudsjetter, latens og beregningskostnader er reelle begrensningerDet skaleres ikke når alle stilguider, API-spesifikasjoner og driftsregler lastes inn i én ledetekst. Ferdigheter lar deg beholde «kald» kunnskap på disk (eller i arkiver) og bare trekke den inn i agentens kontekst når en bestemt funksjon er relevant.

Selskaper som Q2BSTUDIO utnytter denne modellen til å bygge skreddersydde AI-systemer for bedrifter., som vever sammen forretningsintelligens, domenekunnskap og moderne cybersikkerhetspraksis. På den måten er agenter ikke bare dyktige og kontekstbevisste, men også herdet mot vanlige angrepsvektorer i dagens trussellandskap.

Forstå den progressive avsløringsarkitekturen til ADK-ferdigheter

ADK-lignende ferdigheter følger vanligvis en trelags lastemodell som holder agentkontekstfokusert samtidig som det fortsatt er mulig med dyp domenespesialisering når det er nødvendig. Du kan tenke på det som en trinnvis kunnskapskanal:

Nivå 1 – OppdagelseNår en samtale starter, ser agenten bare en katalog over tilgjengelige ferdigheter: navnene deres og korte beskrivelser. Ingen tunge elementer er lastet inn ennå. Dette er nok til at agenten kan bestemme hvilken ferdighet som kan være relevant for brukerens forespørsel.

Nivå 2 – Instruksjoner: når en ferdighet anses som en match, leser agenten dens SKILL.md eller tilsvarende instruksjonsfil. Dette dokumentet gir detaljert veiledning, mønstre og regler for den ferdigheten, og hentes bare inn i modellkonteksten når det er nødvendig.

Nivå 3 – RessurserStore ressurser som store skjemaer, lange sjekklister, skript eller utvidede dokumenter forblir på filsystemet som referanser.

og hentes på forespørsel bare hvis ferdigheten spesifikt peker til dem. Agenten leser eller utfører disse ressursene etter behov, i stedet for å alltid ha dem i hovedledeteksten.

Dette mønsteret er sentralt i rammeverk som AgentKit 2.0 og antigravitasjonsbaserte oppsett.Du kan installere ferdigheter direkte i kompatible agenter (Claude Code, Cursor, Antigravity og andre) ved å bruke kommandoer som npx add-skill vercel-labs/agent-skills, som kloner ferdighetsarkivene, plasserer dem i de riktige mappene og gjør dem synlige uten manuell redigering av ledetekster.

Designmønstre for strukturering av ADK-ferdigheter

Å skrive en ny ferdighet fra bunnen av handler ofte mindre om verktøy og mer om innholdsdesignADK-spesifikasjonen forteller deg vanligvis hvordan du skal strukturere pakken (frontmatter i YAML, references/, assets/, scripts/ kataloger og så videre), men den forteller deg ikke hvordan du skal skrive selve instruksjonene. Det er her gjenbrukbare designmønstre kommer inn i bildet.

Utøvere som har bygget dusinvis av ferdigheter rapporterer at en håndfull strukturelle mønstre dekker de fleste brukstilfeller i den virkelige verden.Fem av de mest nyttige er:

VerktøyinnpakningDette mønsteret innkapsler konvensjonene og beste praksisene til et gitt bibliotek eller en gitt plattform i en ferdighet. Instruksjonene beskriver reglene som skal følges, mens references/ inneholder den offisielle dokumentasjonen. Det finnes vanligvis ingen maler eller skript; poenget er å gi agenten en «mental modell» av et verktøy som FastAPI, React eller Postgres.

GeneratorHer produserer ferdigheten en konsistent strukturert utdata ved hjelp av maler lagret i assets/Eksempler inkluderer API-dokumenter, commit-meldinger, tekniske rapporter eller endringslogger. Instruksjoner definerer kvalitetsregler, mens maler definerer formen på resultatet, slik at du får repeterbare formater med forskjellig innhold hver gang.

Anmelder: dette mønsteret skiller hva å sjekke fra hvordan for å sjekke det. En sjekklistefil i references/ legger ut elementene som skal verifiseres (sikkerhet, stil, arkitektur osv.), mens instruksjonene definerer gjennomgangsprotokollen: grupperer funn etter alvorlighetsgrad, krever begrunnelse, foreslår rettelser. Bytt ut sjekklistefilen, og du får effektivt en helt ny anmelder uten å skrive om ferdigheten.

Intervju (inversjon)I stedet for å handle umiddelbart, intervjuer ferdigheten først brukeren gjennom strukturerte spørsmål i faser, med porter som «ikke begynn å bygge før alle faser er fullførte». Dette hindrer agenten i å gjøre store antagelser og tvinger den til å avklare mål og begrensninger før den genererer detaljerte resultater.

Rørledning: Dette mønsteret koder flertrinns arbeidsflyter med eksplisitte porter på tvers av trinn, for eksempel «ikke fortsett til trinn 3 før brukeren bekrefter». Det er mer komplekst enn de andre, men det er det eneste som pålitelig forhindrer agenter i å hoppe over valideringsfaser. Pipeline-ferdigheter kan inkludere anmeldertrinn, generatorutganger eller intervjufaser i samme flyt.

Ferdigheter fra Google, Vercel og Supabase kombinerer ofte to eller flere av disse mønstrene per ferdighetFor eksempel kan en styringsferdighet intervjue brukeren om prosjektbegrensninger, deretter kjøre en gjennomgangspipeline ved hjelp av distinkte sjekklister og generere en styringsrapport med en maldrevet generator.

Fra enkeltstående agenter til fleragentsystemer med ADK

Når du forstår hvordan ferdigheter pakker kunnskap, er neste trinn å se hvordan ADK-agenter orkestrerer denne kunnskapen i arbeidsflyterGoogles offisielle ADK-kodelaboratorier er en utmerket referanse: de veileder deg fra en grunnleggende enkeltagent gjennom verktøy, minne og koordinering mellom flere agenter, alt i praktiske Colab-notatbøker.

Reisen starter med din første agent bygget med en RunnerI kodelabben definerer du en day_trip_agent som har som mål å lage en dagsreiserute som respekterer brukerens preferanser og budsjett. Tre komponenter illustrerer den generelle ADK-interaksjonsmodellen:

Agenten er «hjernen» definert av instruksjonene, den underliggende modellen (for eksempel Gemini) og verktøyene den kan kalle. I eksemplet har agenten detaljerte retningslinjer pluss tilgang til Google Søk.

Sesjonen fungerer som et samtaleminnelager, og inneholder hele historikken over brukermeldinger og agentsvar. Gjenbruk av samme øktobjekt holder konteksten levende på tvers av runder.

The Runner koordinerer utførelse ved å ta en agent og en økt, behandle hver brukerforespørsel og returnere svaret

mens du oppdaterer økten underveisHjelpearbeidere som run_agent_query() innkapsle denne løkken slik at du enkelt kan utløse agenter gjennom tester eller UI-integrasjoner.

Å lese gjennom dette første eksemplet viser hvordan gode instruksjoner kobles direkte til brukerprompterEn testforespørsel kan be om en «budsjettvennlig» og «avslappende» dagstur, og fordi instruksjonene vektlegger å være kostnadsbevisst, vever agenten pålitelig budsjetthensyn inn i svarene sine.

Koble tilpassede verktøy til ADK-agentene dine

Agenter blir virkelig kraftige når de kan kalle dine egne API-er og interne tjenester i stedet for bare generiske verktøy som nettsøkADK-er gjør dette enkelt ved å gjøre normale funksjoner om til verktøy basert på signaturene og dokumentasjonsstrengene deres.

I kodelabbene bruker et enkelt eksempel en Python-funksjon som kaller et sanntidsvær-APIEn funksjon som get_live_weather_forecast(location: str) henter aktuelle data fra en offentlig værtjeneste og returnerer strukturert informasjon, for eksempel temperatur og forhold i en ordbok.

Den avgjørende delen er dokumentstrengenADK-en analyserer funksjonens dokumentasjonsstreng for å forstå hva verktøyet gjør, hvilke argumenter det tar og hva det returnerer. Språkmodellen leser beskrivelsen og bestemmer når og hvordan verktøyet skal kalles under resonnement.

For å koble verktøyet til en agent, sender du det ganske enkelt som en del av verktøylisten under initialiseringen., Eksempelvis tools=[get_live_weather_forecast]Instruksjonene fra weather_agent kan deretter eksplisitt be modellen om å kalle dette verktøyet før den foreslår utendørsaktiviteter.

Under tester utløser spørsmål som «Jeg vil gå tur i nærheten av Lake Tahoe, hvordan er været?» verktøyet direkte., fordi agentens oppdrag og instruksjoner insisterer på å bruke live-prognosen før en plan anbefales. Dette mønsteret generaliserer til dine egne API-er: lagerbeholdning, prising, CRM, analyser eller enhver backend du kan pakke inn som en funksjon.

Agent-som-verktøy-mønsteret: å bygge team av spesialister

I stedet for å legge alt ansvaret hos én enkelt monolittisk agent, oppfordrer ADK deg til å opprette et team av mindre eksperter.Nøkkelen er Agent-som-verktøy-mønsteret, der én agent kan kalle en annen agent som om det bare var et annet verktøy.

En typisk demonstrasjon i kodelaboratoriene bygger et lagdelt reiseplanleggingssystem:

Spesialister håndtere smale domener: a food_critic_agent som bare foreslår restauranter, en db_agent som spør etter hotelldata, og en concierge_agent som fungerer som en høflig assistent for brukervendte interaksjoner.

Portvakten selv behandler matkritikeren som et verktøy, delegere restaurantutvalget til kritikeren og deretter omformulere resultatet i et mer brukervennlig språk.

På toppen sitter en orkestratoragent, som f.eks. trip_data_concierge_agent, hvis jobb er å forstå brukerens overordnede forespørsel og bestemme hvilken spesialist som skal påkalles gjennom dedikerte wrapper-funksjoner som call_db_agent og call_concierge_agent.

Når du kjører en spørring som «finn et hotell og en restaurant i nærheten for meg», logger fra verktøyene viser en delegeringskjede: orkestratoren ringer DB-agenten for hoteller, deretter concierge-agenten for restaurantråd, og conciergen ringer igjen matkritikeren. Hver agent holder fokus på sitt eget domene mens orkestratoren håndterer komposisjonen.

Denne tilnærmingen samsvarer tett med hvordan AgentKit 2.0 strukturerer sine 16 spesialiserte agenter. på tvers av frontend, backend, sikkerhet, testing og infrastruktur. Hver agent leveres med domenespesifikke ferdigheter (beste praksis for React, databaseoppsett, sikkerhetsrevisjoner, distribusjonsflyter og mer), og en orkestrator setter dem sammen for å oppnå større mål som «bygge og distribuere en brukerautentiseringsmodul».

Å gi agenter hukommelse: økter og adaptiv planlegging

For å føle seg virkelig intelligent, må en agent huske kontekst på tvers av flere runder, tilpasse planer som svar på tilbakemeldinger i stedet for å behandle hver melding som en ny start. Det er her økter og hukommelseshåndtering kommer inn i bildet.

I ADK-kodelaben illustrerer en flerdagers reiseplanlegger forskjellen mellom skikkelig og ødelagt minneEn funksjon som create_multi_day_trip_agent() oppretter en agent hvis instruksjoner vektlegger gradvis planlegging, huske valg og reagerer gjennomtenkt på korrigeringer.

En adaptiv demo bruker et enkelt øktobjekt på nytt i flere runder:

slå 1brukeren ber om en todagers turplan, og agenten foreslår aktiviteter for dag 1.

slå 2Brukeren sier at de ikke er interessert i slott. Fordi økten inneholder den tidligere reiseruten, vet agenten hvilken del som skal justeres og foreslår et alternativ for det segmentet samtidig som andre detaljer beholdes.

slå 3Brukeren bekrefter endringen og spør om de neste trinnene, slik at agenten fortsetter med planleggingen for dag 2, klar over all tidligere kontekst.

En kontrasterende «feil»-demo skaper en ny økt for hver turAgenten svarer riktig på det første spørsmålet, men når brukeren senere refererer til «dag 2», har den nye økten ingen historikk, og agenten har i hovedsak hukommelsestap og kan ikke knytte forespørselen tilbake til den tidligere planen.

Konklusjonen er enkel, men grunnleggende: kontinuerlige samtaler krever kontinuerlige økterFor produksjonssystemer må du lagre og hente øktstatus på tvers av API-kall, enheter og noen ganger til og med brukere, spesielt når arbeidsflyter strekker seg over dager eller uker.

Ruteragenten: videresender spørsmål til riktig spesialist

Etter hvert som katalogen din over agenter og ferdigheter vokser, trenger du en mekanisme for å sende hver innkommende forespørsel til riktig ekspert.Det er jobben til en ruteragent, en liten, men avgjørende komponent i arkitekturer med flere agenter.

En ruters hovedansvar er klassifisering snarere enn å svare direkte på brukerspørsmål.Instruksjonene ber den vanligvis om å lese en brukerforespørsel og bare skrive ut navnet på den best egnede agenten (eller arbeidsflyten) for den jobben.

I fleragentseksjonene i kodelabben velger ruteren mellom ulike domeneagenter. for eksempel en dagsturplanlegger, en matagent eller en transportagent. Utførelsesfunksjonen ber først ruteren om en rute, og bruker deretter enkel betinget logikk for å kalle på riktig spesialist basert på ruterens svar.

Dette mønsteret samsvarer med hvordan multiagentorkestering er beskrevet i AgentKit 2.0Der mottar en orkestratoragent et mål på overordnet nivå, delegerer skjemadesign til en databaseagent, skjemastillas til en frontend-agent, kjører en sikkerhetsgjennomgang, overleverer deretter til en distribusjonsagent og aggregerer til slutt differens og URL-er til et sammenhengende sammendrag for brukeren.

SequentialAgent: orkestrering av ordnede flertrinns arbeidsflyter

Noen oppgaver deles naturlig inn i ordnede stadier der resultatet fra ett trinn går over i det neste.For eksempel krever «finn den beste sushien i Palo Alto, og fortell meg deretter hvordan jeg kommer meg dit» tydeligvis først et oppdagelsestrinn og deretter et navigasjonstrinn.

ADK-er tilbyr en spesialisert arbeidsflytagent, ofte kalt SequentialAgent, for å håndtere disse kjedene på en ryddig måteI stedet for å skrive manuell orkestreringslogikk, definerer du en liste over underagenter og delte tilstandsnøkler, og rammeverket tar seg av sekvensering og dataoverføring.

I kodelab-eksemplet blir foodie-agenten refaktorisert for å sende ut resultatet under en output_key i likhet med "destination"Transportagentens instruksjoner inkluderer deretter en midlertidig løsning, for eksempel {destination} som ADK automatisk fyller med den lagrede verdien fra delt tilstand.

Den overordnede arbeidsflytagenten, si find_and_navigate_agent, er konfigurert som en SequentialAgent med underagenter i en fast rekkefølge i likhet med [foodie_agent, transportation_agent]Når den kalles, oppfører den seg som én enkelt agent fra innringerens perspektiv, samtidig som den internt koordinerer de to trinnene og administrerer den delte tilstanden.

Denne tilnærmingen forenkler orkestreringskoden drastiskBetingede trær og ad-hoc-datakabling forsvinner, erstattet av deklarative definisjoner av underagenter og nøkler. Det gjør det også enklere å teste og utvide arbeidsflyter, siden hver underagent forblir modulær og kan gjenbrukes i andre kjeder.

LoopAgent: iterativ forbedring med planlegger, kritiker og forbedringsarbeider

Mange problemer i den virkelige verden drar nytte av iterativ forbedring i stedet for enkeltstående løsninger.Tenk deg å utarbeide en plan, kritisere den, forbedre den og gjenta den til en viss kvalitetsstandard er oppfylt. Løkkede arbeidsflyter dekker dette behovet.

ADK-er fanger opp dette mønsteret med en LoopAgent, en arbeidsflytagent som gjentatte ganger kjører en sekvens av underagenter inntil en avslutningsbetingelse utløsesDette er ideelt for «perfeksjonistiske» agenter som trenger å evaluere seg selv og justere sine egne resultater basert på formelle kriterier.

Et klassisk loop-oppsett inkluderer tre rolleren planleggeragent som produserer en innledende plan, en kritikeragent som evaluerer planen opp mot begrensninger og en raffineringsagent som redigerer eller omskriver planen basert på kritikerens tilbakemeldinger.

Løkkedefinisjonen kobler disse rollene til en syklus med et maksimalt antall iterasjoner. for å unngå uendelige løkker, for eksempel max_iterations=3Ved hver omgang avgjør kritikeren om planen er akseptabel; hvis ikke, genererer raffinøren en revidert versjon, og løkken fortsetter.

Å gå ut av løkken krever vanligvis et spesialverktøy, Eksempel exit_loop, som raffinøren ringer når kritikerens evaluering blir positiv. På det tidspunktet returneres den endelige validerte planen til brukeren eller sendes til agenter nedstrøms.

Dette mønsteret er spesielt nyttig innen domener som arkitekturdesign, sikkerhetsgjennomgang eller innholdsproduksjon, hvor engangssvar sjelden er gode nok og innebygde kritikksykluser kan heve gjennomsnittlig kvalitet betraktelig.

ParallelAgent: øker hastigheten på arbeidet med samtidige underagenter

Når ulike deler av en brukers forespørsel er uavhengige, kaster det bort tid å kjøre dem sekvensieltFor eksempel krever ikke «finn et museum, en konsert og en flott restaurant for i kveld» at hvert søk venter på de andre.

Parallelle arbeidsflyter løser dette ved å lansere flere spesialister samtidig.I ADK-er, en ParallelAgent kjører en liste over underagenter samtidig, og slår deretter sammen resultatene deres gjennom delt tilstand og et siste syntesetrinn.

Et typisk oppsett definerer tre domenespesifikke agenter i likhet med museum_finder, concert_finder og restaurant_finder, hver med sin egen output_key i delt tilstand. Den parallelle agenten utfører alle tre parallelt, så den totale tiden er nær den tregeste enkeltagenten i stedet for summen av alle tre.

Etter at disse agentene er fullført, leser en synteseagent plassholdere som {museum_result}, {concert_result} og {restaurant_result} fra den delte tilstanden, og lager deretter et sammenhengende og brukervennlig svar som blander alle tre informasjonssporene.

Dette mønsteret speiler fordelene med «parallell utførelse» som er beskrevet i AgentKit 2.0s orkestreringsflyter.Uavhengige underagenter leverer arbeidet sitt samtidig, isolert av sine egne ferdigheter, slik at de ikke forurenser hverandres kontekst, mens orkestratoren opprettholder generell feiltoleranse og reviderbarhet.

AgentKit 2.0, fellesskapsferdigheter og modulær agentorkestrering

AgentKit 2.0 viser hvordan et modent økosystem av ADK-ferdigheter og agenter ser ut i praksis.Den leveres med 16 spesialiserte agenter som spenner over frontend, backend, sikkerhet, testing og infrastruktur, hver forhåndsutstyrt med domeneferdigheter slik at de kan operere autonomt på komplekse deloppgaver.

Mer enn 40 domenefokuserte ferdigheter er inkludert i leveransen, som dekker tilbakevendende områder som autentiseringsflyter, databasekonfigurasjon, sanntidsdistribusjoner og ytelsesovervåking. Dette er nettopp de delene av moderne stakker som vanligvis krever mest ingeniørtid.

I tillegg bidrar det bredere fellesskapet med mer enn 1,000 vedlikeholdte ferdigheterSammen med rammeverk som Agent MD, lar disse ferdighetene agenter tolke detaljerte driftsregler og anvende dem konsekvent på tvers av store, intrikate kodebaser og flerlagsdistribusjoner.

Kjernefilosofien er modulær, agentdrevet utviklingI stedet for at én megaagent prøver å gjøre alt, setter du sammen et team av smale spesialister og orkestrerer dem. Hver agent laster bare inn de ferdighetene den trenger for sitt domene, og samsvarer med den samme progressive avsløringsmodellen som brukes på ferdighetsnivået.

Typiske orkestreringsflyter følger et tydelig mønsterEn orkestratoragent mottar et mål på toppnivå, overfører databasedesign til en DB-agent (ved hjelp av en skjemaferdighet), sender UI-stillas til en frontend-agent (med React beste praksisferdigheter), kjører en sikkerhetsagent for revisjoner og ber til slutt en distribusjonsagent om å pushe til infrastruktur som InForge. Gjennom hele prosessen samler orkestratoren resultater, prøver mislykkede trinn på nytt når det er nødvendig og logger interaksjoner for revisjon.

Denne arkitekturen forbedrer ikke bare ytelse og pålitelighet, den skalerer også etter hvert som ferdighetene i fellesskapet vokser til tusenvisDu trenger ikke lenger én agent som vet alt; i stedet er du avhengig av et sammensatt team der hvert medlem holder seg skarpt innenfor sine egne ferdigheter.

Praktisk: kjøre ADK-webagenter lokalt på macOS, Linux og Windows

Alle disse konseptene blir mye tydeligere når du spinner opp en ekte ADK-drevet agent på din egen maskinADK Web-oppsettet som finnes i eksempelrepositoriene lar deg kjøre en agent for planlegging av dagsturer lokalt med et enkelt webgrensesnitt.

Før du starter, trenger du noen forkunnskaperPython 3.8 eller nyere (3.9+ anbefales), en Google AI Studio API-nøkkel og en internettforbindelse. For nyere Python-versjoner kan du installere google-adk==1.5.0, mens Python 3.8-brukere bør bruke en kompatibel versjon som google-adk==0.3.0.

Den grunnleggende flyten for macOS og Linux begynner med å klone depotet og sette opp et virtuelt miljø.Etter å ha løpt git clone og cd i prosjektet, kan du enten kjøre et automatisk skript som ./setup_venv.sh (etter å ha gitt utførelsestillatelser) eller manuelt opprette og aktivere et virtuelt miljø med python3 -m venv .adk_env og source .adk_env/bin/activate, Etterfulgt av pip install -r requirements.txt.

Et viktig trinn er å sette miljøvariabler via en .env fil i agent/ katalogDu oppretter denne filen, åpner den i et redigeringsprogram og legger til linjer som GOOGLE_GENAI_USE_VERTEXAI=FALSE og GOOGLE_API_KEY=your_actual_api_key_here, og erstatter plassholderen med din virkelige API-nøkkel. Hvis du hopper over dette trinnet, kan agenten ikke kalle de underliggende modellene.

Når miljøet er aktivt, kjører du bare adk web for å starte det lokale webgrensesnittetTerminalen viser vanligvis en URL http://localhost:8000, hvor du kan åpne nettleseren din, velge agent alternativ fra en rullegardinmeny og begynn å chatte med dagsturplanleggeren. Når du er ferdig, deaktiverer du det virtuelle miljøet med deactivate kommando.

Windows-brukere følger et veldig lignende mønster ved å bruke kommandoprompt eller PowerShellEtter at du har klonet depotet og endret til det, kan du kjøre et praktisk skript som setup_venv.bat eller opprett en venv manuelt med python -m venv .adk_env og aktiver den via .adk_env\Scripts\activate i ledeteksten eller .adk_env\Scripts\Activate.ps1 i PowerShell.

Ocuco .env filen på Windows lever i det samme agent\ katalog, laget for eksempel med type nul > agent\.env og redigeres med Notisblokk. Deretter legger du til de samme nøkkelverdiparene for å konfigurere Google AI-tilgang. Hvis du støter på problemer med utførelsespolicyen i PowerShell, kan en kommando som Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser løser dem for lokale skript.

Etter at du har installert avhengigheter og konfigurert miljøvariablene dine, kjører du adk web gir deg den samme nettleserbaserte agentopplevelsen på Windows som på macOS eller Linux, med muligheten til å deaktivere miljøet når som helst ved hjelp av deactivate.

ADK-agenter med ferdigheter, progressiv avsløring og multiagentorkestering gir en kraftig måte å bygge skalerbare, sikre og høyt spesialiserte AI-systemer på. som samsvarer med reelle programvarearbeidsflyter. Ved å strukturere ferdigheter med solide designmønstre, koble agenter til dine egne verktøy og API-er, utnytte ruter-, sekvensielle-, løkke- og parallellagenter og kjøre oppsett lokalt eller i skyen, kan team gå fra enkle chatboter til robuste AI-samarbeidspartnere som jobber sammen med utviklere, analytikere og operatører i det daglige arbeidet.