Google ADK -opas: Rakenna tekoälyagentteja nollasta tuotantoon

Google ADK -opas: Rakenna tekoälyagentteja nollasta tuotantoon

Googlen Agent Development Kit (ADK) on viitekehys, joka vihdoin tekee moniagenttijärjestelmistä lähestyttäviä. Jos olet rakentanut tekoälyagentteja LangChainilla tai CrewAI:lla ja sinusta on tuntunut, että taistelet viitekehystä vastaan sen sijaan että rakentaisit sen avulla, tämä Google ADK -opas vie sinut läpi kaiken — ensimmäisestä agentistasi sen käyttöönottoon Cloud Runissa.

Mikä on Google ADK (ja miksi sinun pitäisi välittää)?

Googlen Agent Development Kit (ADK) on avoimen lähdekoodin Python-viitekehys tekoälyagenttien rakentamiseen, arviointiin ja käyttöönottoon. Se julkaistiin vuonna 2025, ja se on optimoitu Geminalle, mutta tukee yli sataa mallia LiteLLM:n kautta. ADK:n tappajaominaisuus on natiivi moniagenttien orkestrointi — agentit, jotka delegoivat tehtäviä toisille agenteille ilman liimakoodia.

Kun olemme rakentaneet agentteja LangChainilla, CrewAI:lla ja nyt ADK:lla, yksi erottuu: ADK on mielipiteellinen oikeissa kohdissa. Se antaa sinulle projektirakenteen, sisäänrakennetun kehittäjäkäyttöliittymän ja käyttöönotto-komennon. Et kokoa viittä kirjastoa yhteen saadaksesi perusagentin toimimaan.

Jos LangChain on yleisveitsi, ADK on Googlen varta vasten rakennettu työkalupakki moniagenttityönkuluihin. CrewAI on filosofialtaan lähempänä — roolipohjaisia agentteja, jotka tekevät yhteistyötä — mutta ADK menee pidemmälle sisäänrakennetulla arvioinnilla, natiivilla Gemini-optimoinnilla ja yhden komennon Cloud Run -käyttöönotolla. Syvempää erittelyä varten katso syvällinen vertailumme agenttikehyksistä.

Kenelle ADK on tarkoitettu? Python-kehittäjille, jotka haluavat jäsenneltyjä moniagenttijärjestelmiä. Tiimeille, jotka ovat jo Google Cloudissa tai Geminissä. Kenelle tahansa, jota kyllästyttää boilerplate-orkestrointilogiikan kirjoittaminen.

Näin kehykset vertautuvat yhdellä silmäyksellä:

Lyhyt versio: jos haluat nopeimman tien "ideasta" "käyttöön otettuun moniagenttijärjestelmään", ADK:ta on vaikea voittaa juuri nyt.

Edellytykset ja Google ADK:n asennus

Aloittaaksesi Google ADK:n tarvitset Python 3.9+:n, Gemini API -avaimen (ilmainen taso saatavilla Google AI Studiossa) ja google-adk-paketin. Asenna komennolla pip install google-adk, aseta API-avaimesi ympäristömuuttujaksi, ja olet valmis rakentamaan ensimmäisen agenttisi alle viidessä minuutissa.

Tässä on asennustarkistuslistasi:

• Python 3.9+ (3.10+ suositellaan täydelle type hint -tuelle)
• Gemini API -avain — nappaa ilmainen osoitteesta aistudio.google.com. Ilmaisella tasolla saat 15 pyyntöä minuutissa, mikä riittää hyvin kehitykseen.
• pip (tai uv, jos suosit nopeutta — uv pip install google-adk toimii myös)

Asenna paketti ja aseta avaimesi:

pip install google-adk

# Set your API key (add to .bashrc/.zshrc for persistence)
export GOOGLE_API_KEY="your-api-key-here"

ADK odottaa tiettyä kansiorakennetta. Jokainen agentti asuu omassa pakettihakemistossaan:

my_agent/
  __init__.py    # Exports root_agent
  agent.py       # Agent definition
.env             # Optional: GOOGLE_API_KEY=your-key

Kansion nimestä tulee agenttisi paketin nimi, joten valitse jotain kuvaavaa. Älä kutsu sitä test:ksi tai agent:ksi — sekoitat Pythonin tuontijärjestelmän.

Ammattilaisvinkki: Jos käytät uv:tä, luo ensin virtuaaliympäristö komennolla uv venv && source .venv/bin/activate. Se on huomattavasti tavallista pipiä nopeampi riippuvuuksien selvittämisessä.

Ensimmäisen Google ADK -agenttisi rakentaminen

Ensimmäinen ADK-agenttisi tarvitsee vain kolme asiaa: nimen, mallin (kuten gemini-2.0-flash) ja ohje-merkkijonon. Määrittele se tiedostoon agent.py, sijoita se kansioon, jossa on __init__.py, ja aja adk web keskustellaksesi sen kanssa selainkäyttöliittymässä. Koko asennus vie noin 10 riviä Pythonia.

Luo kansio nimeltä my_agent ja lisää kaksi tiedostoa. Ensin agentin määrittely:

# my_agent/agent.py
from google.adk.agents import LlmAgent

root_agent = LlmAgent(
    name="my_assistant",
    model="gemini-2.0-flash",
    instruction="""You are a helpful coding assistant. 
    You explain concepts clearly and provide working code examples.
    Keep responses concise but thorough.""",
    description="A coding assistant that explains concepts and writes code"
)

Sitten init-tiedosto, joka vie agenttisi:

# my_agent/__init__.py
from .agent import root_agent

Tuolla muuttujan nimellä on väliä — ADK etsii nimenomaan root_agentia. Jos unohdat tämän, saat "agent not found" -virheen, joka ei selitä miksi.

Nyt aja se. Sinulla on kaksi vaihtoehtoa:

# CLI mode -- chat in your terminal
adk run my_agent

# Web UI mode -- opens a browser interface
adk web my_agent

adk web -käyttöliittymä on aidosti hyödyllinen. Se näyttää sinulle koko keskustelujäljen — mitä työkaluja agentti kutsui, mitä malli vastaanotti ja mitä se palautti. Ajattele sitä agenttisi Chrome DevToolsina. Kun alat rakentaa moniagenttijärjestelmiä myöhemmin, tästä tulee välttämätön delegointivuon ymmärtämiselle.

Kokeile muokata ohjetta nähdäksesi, miten käyttäytyminen muuttuu. Tee siitä merirosvo. Laita se vastaamaan vain haikuina. Tuntuman saaminen siihen, miten ohjeet muovaavat käyttäytymistä, on perusta kaikelle muulle tässä oppaassa.

Omien työkalujen lisääminen Google ADK -agentillesi

ADK-agenteista tulee hyödyllisiä, kun annat niille työkaluja. Määrittele Python-funktio, jolla on selkeä docstring, ja ADK muuntaa sen automaattisesti työkaluksi, jota agentti voi kutsua. Docstring on ratkaiseva — se kertoo mallille, mitä työkalu tekee ja milloin sitä käytetään. ADK:n mukana tulee myös sisäänrakennettuja työkaluja, kuten Google Search ja koodin suoritus.

Työkalut ovat agentin kädet. Ilman niitä agenttisi voi vain puhua. Niiden kanssa se voi tarkistaa tietokantoja, kutsua API-rajapintoja, suorittaa laskelmia ja olla vuorovaikutuksessa ulkoisten järjestelmien kanssa. Jos haluat ymmärtää, miten function calling toimii konepellin alla, meillä on siitä erillinen syvällinen artikkeli.

Omat funktiotyökalut

Tässä on käytännöllinen esimerkki — työkalu, joka hakee osakekursseja:

# my_agent/agent.py
from google.adk.agents import LlmAgent

def get_stock_price(ticker: str) -> dict:
    """Get the current stock price for a given ticker symbol.
    
    Args:
        ticker: The stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT')
    
    Returns:
        A dictionary with the ticker and its current price.
    """
    # In production, you'd call a real API here
    mock_prices = {"AAPL": 198.50, "GOOGL": 175.20, "MSFT": 425.80}
    price = mock_prices.get(ticker.upper(), None)
    if price:
        return {"ticker": ticker.upper(), "price": price, "currency": "USD"}
    return {"error": f"Ticker {ticker} not found"}

root_agent = LlmAgent(
    name="finance_assistant",
    model="gemini-2.0-flash",
    instruction="You help users check stock prices. Use the get_stock_price tool when asked about any stock.",
    tools=[get_stock_price],
    description="A financial assistant that looks up stock prices"
)

Huomaa type hintit ja docstring. Ne eivät ole valinnaisia koristeita — ADK käyttää niitä luodakseen työkalun skeeman, jonka malli näkee. Jätä docstring pois, eikä malli tiedä, milloin kutsua funktiotasi. Jätä type hintit pois, ja saat allekirjoitusvirheen.

Sisäänrakennetut työkalut (Google Search, koodin suoritus)

ADK:n mukana tulee työkaluja, jotka voit lisätä kirjoittamatta lainkaan koodia:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search, code_execution

root_agent = LlmAgent(
    name="research_agent",
    model="gemini-2.0-flash",
    instruction="You research topics using Google Search and can run Python code to analyze data.",
    tools=[google_search, code_execution],
    description="A research agent with search and code execution capabilities"
)

google_search antaa agentin kysyä verkosta reaaliajassa. code_execution antaa sille hiekkalaatikkona toimivan Python-ympäristön laskelmien suorittamiseen. Nämä kaksi yksinään kattavat yllättävän määrän käyttötapauksia.

Moniagenttijärjestelmät: Miten Google ADK -agentit delegoivat työtä

ADK:n moniagenttijärjestelmä käyttää juuriagenttia, joka delegoi tehtäviä erikoistuneille aliagenteille. Jokainen aliagentti hoitaa yhtä toimialuetta — tutkimusta, kirjoittamista, koodausta. Juuriagentti päättää, mitä aliagenttia kutsutaan, käyttäjän pyynnön perusteella. Voit myös käyttää agentti-työkaluna-mallia, jossa yksi agentti kutsuu toista ikään kuin se olisi funktio. Googlen virallinen blogi moniagenttijärjestelmistä syventyy arkkitehtuurimalleihin tarkemmin.

Ajattele sitä projektipäällikkönä, joka delegoi asiantuntijoille. Juuriagentti lukee käyttäjän pyynnön, selvittää, kenen asiantuntijan pitäisi hoitaa se, ja reitittää sen mukaisesti. Asiantuntijat eivät tiedä toisistaan — ne vain tekevät työnsä ja raportoivat takaisin.

Juuriagentti + aliagentit -malli

Tässä on toimiva esimerkki juuriagentista, joka delegoi tutkimusagentille ja kirjoitusagentille:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search

# Sub-agent 1: handles research
research_agent = LlmAgent(
    name="researcher",
    model="gemini-2.0-flash",
    instruction="You research topics thoroughly using Google Search. Return factual, well-sourced information.",
    tools=[google_search],
    description="Researches topics and returns factual information"
)

# Sub-agent 2: handles writing
writing_agent = LlmAgent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="You write clear, engaging content based on provided information. Focus on readability and accuracy.",
    description="Writes polished content from research notes"
)

# Root agent: delegates to the right sub-agent
root_agent = LlmAgent(
    name="content_manager",
    model="gemini-2.0-flash",
    instruction="""You manage content creation. 
    - When the user wants information gathered, delegate to the researcher.
    - When the user wants content written or edited, delegate to the writer.
    - You can chain both: research first, then write.""",
    sub_agents=[research_agent, writing_agent],
    description="Manages content creation by delegating to research and writing specialists"
)

Kunkin aliagentin description-kenttä on tapa, jolla juuriagentti ymmärtää, mitä ne osaavat. Kirjoita selkeitä kuvauksia — epämääräiset johtavat huonoihin reitityspäätöksiin.

Agentti-työkaluna-malli

Joskus haluat enemmän hallintaa siihen, miten yksi agentti kutsuu toista. Agentti-työkaluna-malli käärii aliagentin kutsuttavaksi työkaluksi:

from google.adk.tools import agent_tool

research_tool = agent_tool.AgentTool(agent=research_agent)

root_agent = LlmAgent(
    name="writer_with_research",
    model="gemini-2.0-flash",
    instruction="You write articles. Use the research tool to gather facts before writing.",
    tools=[research_tool],
    description="A writer that can research topics on demand"
)

Käytä aliagentteja, kun haluat juuriagentin delegoivan hallinnan kokonaan. Käytä agentti-työkaluna-mallia, kun haluat kutsuvan agentin pysyvän kuskin paikalla ja käyttävän vain aliagentin tuotosta syötteenä. Jos rakennat järjestelmiä, joissa agentit tarvitsevat jaettua kontekstia, katso kattava oppaamme agenttien muistiarkkitehtuureista.

Työnkulkuagentit: peräkkäinen, rinnakkainen ja silmukka

LLM-ohjatun delegoinnin lisäksi ADK tarjoaa kolme työnkulkuagenttityyppiä deterministiseen orkestrointiin: SequentialAgent ajaa aliagentit yksi toisensa jälkeen, ParallelAgent ajaa ne samanaikaisesti ja LoopAgent toistaa sekvenssiä, kunnes ehto täyttyy. Näistä on hyötyä, kun tarvitset ennustettavan suoritusjärjestyksen sen sijaan, että antaisit LLM:n päättää.

Ero on merkityksellinen. LLM-ohjattu delegointi (yllä oleva sub_agents-malli) antaa mallin valita, ketä kutsutaan. Työnkulkuagentit antavat sinulle ohjelmallisen hallinnan. Käytä työnkulkuagentteja, kun suoritusjärjestys tunnetaan etukäteen.

from google.adk.agents import SequentialAgent, ParallelAgent, LlmAgent

# Three agents that must run in order
research_agent = LlmAgent(name="researcher", model="gemini-2.0-flash",
    instruction="Research the given topic.", description="Researches topics")
    
draft_agent = LlmAgent(name="drafter", model="gemini-2.0-flash",
    instruction="Write a draft based on the research.", description="Writes drafts")
    
review_agent = LlmAgent(name="reviewer", model="gemini-2.0-flash",
    instruction="Review the draft for accuracy and clarity.", description="Reviews content")

# Pipeline: research -> draft -> review
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Riippumattomille tehtäville, jotka voivat ajaa samaan aikaan, ParallelAgent säästää todellista aikaa:

# Three data fetchers that run concurrently
fetch_news = LlmAgent(name="news_fetcher", model="gemini-2.0-flash",
    instruction="Fetch latest tech news.", description="Fetches news")
    
fetch_stocks = LlmAgent(name="stock_fetcher", model="gemini-2.0-flash",
    instruction="Fetch stock market summary.", description="Fetches stocks")
    
fetch_weather = LlmAgent(name="weather_fetcher", model="gemini-2.0-flash",
    instruction="Fetch weather forecast.", description="Fetches weather")

morning_briefing = ParallelAgent(
    name="morning_briefing",
    sub_agents=[fetch_news, fetch_stocks, fetch_weather],
    description="Gathers morning briefing data in parallel"
)

Tilan ja muistin hallinta

ADK hallitsee agentin tilaa kahdella tasolla: istunnon tila (data keskustelun sisällä, kuten käyttäjän asetukset, jotka kerätään keskustelun aikana) ja muistipalvelut (data, joka säilyy keskustelujen välillä). Istunnon tila on yksinkertainen avain-arvo-tallenne, jota käytetään context.state:n kautta. Muisti käyttää palveluita, kuten InMemoryMemoryService tai VertexAIMemoryBankService tuotantoon.

Istunnon tila on yksinkertaisempi. Se on jokaiseen keskusteluun liitetty sanakirja:

from google.adk.agents import LlmAgent

def save_preference(key: str, value: str, context) -> str:
    """Save a user preference to session state.
    
    Args:
        key: The preference name (e.g., 'language', 'theme')
        value: The preference value
        context: The ADK context object
    
    Returns:
        Confirmation message
    """
    context.state[key] = value
    return f"Saved preference: {key} = {value}"

def get_preference(key: str, context) -> str:
    """Retrieve a user preference from session state.
    
    Args:
        key: The preference name to look up
        context: The ADK context object
    
    Returns:
        The preference value or a not-found message
    """
    value = context.state.get(key, "Not set")
    return f"{key} = {value}"

root_agent = LlmAgent(
    name="personalized_assistant",
    model="gemini-2.0-flash",
    instruction="You remember user preferences. Save them when told, recall them when asked.",
    tools=[save_preference, get_preference],
    description="An assistant that remembers user preferences"
)

Keskustelujen väliselle muistille — sille, jossa agenttisi muistaa käyttäjän viime tiistailta — tarvitset muistipalvelun:

from google.adk.memory import InMemoryMemoryService

# For development (data lost on restart)
memory_service = InMemoryMemoryService()

# For production, use VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

Milloin tarvitset muistia etkä istunnon tilaa? Jos kyse on yhdestä keskustelusta (ostoskori, nykyisen tehtävän konteksti), käytä istunnon tilaa. Jos sen on säilyttävä keskustelujen välillä (käyttäjän asetukset, aiemmat vuorovaikutukset), käytä muistipalvelua. Katso kattava oppaamme agenttien muistiarkkitehtuureista tuotantomalleja varten.

Callbackit: Agentin käyttäytymisen hallinta

ADK-callbackit antavat sinun kaapata ja muokata agentin käyttäytymistä neljässä kohdassa: before_model_callback (ennen LLM-kutsua), after_model_callback (LLM-vastauksen jälkeen), before_tool_callback (ennen työkalun suoritusta) ja after_tool_callback (työkalun tuloksen jälkeen). Käytä niitä syötteen validointiin, turvallisuussuodatukseen, lokitukseen tai vastausten muokkaamiseen ennen kuin ne saavuttavat käyttäjän.

Callbackit ovat paikka, johon lisäät suojakiskot. Ajattele niitä agenttisi väliohjelmistona — jokainen pyyntö ja vastaus kulkee niiden läpi, ja voit tarkastella, muokata tai estää mitä tahansa.

from google.adk.agents import LlmAgent

def safety_filter(callback_context, llm_request):
    """Block requests containing harmful content patterns."""
    user_message = str(llm_request)
    blocked_patterns = ["ignore your instructions", "pretend you are"]
    
    for pattern in blocked_patterns:
        if pattern.lower() in user_message.lower():
            # Return a response directly, skipping the model call
            return {"blocked": True, "reason": "Request matched safety filter"}
    
    # Return None to proceed normally
    return None

def log_tool_usage(callback_context, tool_name, tool_result):
    """Log every tool call for monitoring."""
    print(f"[TOOL LOG] {tool_name}: {tool_result}")
    return None  # Don't modify the result

root_agent = LlmAgent(
    name="safe_assistant",
    model="gemini-2.0-flash",
    instruction="You are a helpful assistant.",
    before_model_callback=safety_filter,
    after_tool_callback=log_tool_usage,
    description="A safety-filtered assistant with tool logging"
)

before_model_callback on tärkein tuotannossa. Se ajaa ennen jokaista LLM-kutsua ja antaa sinulle mahdollisuuden estää prompt injection -hyökkäyksiä, validoida syötteitä tai lisätä järjestelmäkontekstia. Jos palautat vastausobjektin, ADK ohittaa mallin kokonaan. Palauta None päästääksesi pyynnön läpi. Lisää malleja löydät syvemmistä LLM-turvallisuuden suojakiskomalleista.

ADK-agenttiesi testaaminen ja arviointi

ADK sisältää sisäänrakennetun arviointikehyksen, jossa on kaksi arvioijaa: ResponseEvaluator tarkistaa, onko agentin lopullinen vastaus oikein, ja TrajectoryEvaluator varmistaa, että agentti otti oikeat askeleet — kutsui oikeita työkaluja oikeassa järjestyksessä. Kirjoita testitapaukset JSON-tiedostoina ja aja ne pytestillä havaitaksesi regressiot ennen käyttöönottoa.

Miksi agentteja kannattaa testata? Koska ne ovat epädeterministisiä. Sama syöte voi tuottaa eri tuloksia, ja pieni muutos ohjeeseesi voi rikkoa työkalujen kutsumisen hienovaraisin tavoin. Kokemuksemme mukaan agentit, jotka läpäisevät trajektori-arvioinnin, ovat paljon luotettavampia tuotannossa kuin ne, joita testataan vain lopullisen tuloksen laadulla. Laajempia arviointistrategioita varten katso oppaamme LLM-arviointistrategioihin.

Testitapauksesi menevät JSON-tiedostoon:

[
  {
    "input": "What's the stock price of AAPL?",
    "expected_output": "198.50",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}}
    ]
  },
  {
    "input": "Compare AAPL and GOOGL prices",
    "expected_output": "AAPL.*198.*GOOGL.*175",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}},
      {"tool_name": "get_stock_price", "args": {"ticker": "GOOGL"}}
    ]
  }
]

Aja sitten arvioinnit pytestillä. ADK Python -repositoriossa on täysi arviointi-API-viite:

# test_agent.py
import pytest
from google.adk.evaluation import ResponseEvaluator, TrajectoryEvaluator

def test_stock_agent_response():
    evaluator = ResponseEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.8, f"Response pass rate too low: {results.pass_rate}"

def test_stock_agent_trajectory():
    evaluator = TrajectoryEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.9, f"Trajectory pass rate too low: {results.pass_rate}"

Aja komennolla pytest test_agent.py -v. Aseta kynnyksesi kriittisyyden perusteella — 80 % vastaustarkkuus saattaa riittää luovalle kirjoitusagentille, mutta haluat 95 %+ mille tahansa, mikä käsittelee talousdataa.

Google ADK -agenttisi käyttöönotto tuotantoon

Ota ADK-agenttisi käyttöön Google Cloud Runissa yhdellä komennolla: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK pakkaa koodisi, rakentaa kontin ja käynnistää palvelimettoman päätepisteen. Hallinnoituun hostaukseen käytä Vertex AI Agent Engineä. Mukautetulle infrastruktuurille ADK tukee myös Docker-kontitusta.

Olemme ottaneet ADK-agentteja käyttöön Cloud Runissa sisäisiä työkaluja varten, ja cold start -ajat ovat yllättävän nopeita — alle 3 sekuntia perusagentille. Tuotantojärjestelmissä harkitse käyttöönoton yhdistämistä tuotantoagenttien valvontatyökaluihin.

Käyttöönotto Cloud Runiin (suositeltu useimmille)

Cloud Run on yksinkertaisin polku. Yksi komento, ja agenttisi on elossa HTTPS-päätepisteellä:

adk deploy cloud_run \
  --project your-gcp-project-id \
  --region us-central1 \
  --service-name my-agent-service \
  --with_ui

--with_ui-lippu ottaa käyttöön ADK-verkkokäyttöliittymän agenttisi rinnalla, joten saat selainpohjaisen chatin testaamiseen tuotannossa. Kulissien takana ADK rakentaa konttikuvan, työntää sen Google Artifact Registryyn ja luo Cloud Run -palvelun. Täysi käyttöönoton kulku on dokumentoitu Googlen Cloud Run -pikaoppaassa ADK:lle.

Mukautetulle infrastruktuurille tässä on minimaalinen Dockerfile:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8080
CMD ["adk", "api_server", "--port", "8080", "my_agent"]

Vaihtoehto: Vertex AI Agent Engine

Yritystiimeille, jotka tarvitsevat hallinnoitua skaalausta, valvontaa ja versiointia, Vertex AI Agent Engine hoitaa infrastruktuurin kokonaan. Vaihdät joustavuutta mukavuuteen — ei hallinnoitavia kontteja, automaattinen skaalaus, sisäänrakennettu analytiikka.

Kustannusnäkökohdat

Todelliset luvut, jotka sinun tulisi tietää:

• Gemini API:n ilmainen taso: 15 pyyntöä minuutissa, 1 miljoona tokenia/päivä. Riittää kehitykseen ja kevyisiin demoihin.
• Gemini 2.0 Flash (maksullinen): $0,10 per miljoona syötetokenia, $0,40 per miljoona tulostokenia. Riittävän halpa tuotantoon.
• Cloud Runin ilmainen taso: 2 miljoonaa pyyntöä/kk, 360 000 GB-sekuntia laskentaa. Perusagentti, joka käsittelee 1 000 pyyntöä/päivä, pysyy hyvin ilmaisella tasolla.
• Optimointivinkki: Käytä gemini-2.0-flashia (ei gemini-2.0-pro) aliagenteille, jotka tekevät yksinkertaista reititystä tai muotoilua. Säästä kyvykkäämmät mallit agenteille, jotka tekevät monimutkaista päättelyä.

Miten Techsy lähestyy tekoälyagenttien kehitystä

Techsyllä olemme rakentaneet moniagenttijärjestelmiä asiakkaille käyttäen ADK:ta, LangGraphia ja CrewAI:ta. Kehysvalinta riippuu pinostasi: jos olet jo Google Cloudissa, ADK poistaa paljon integraatiokitkaa. Jos tarvitset usean tarjoajan LLM-tuen alusta alkaen, LangGraph antaa sinulle enemmän joustavuutta.

Tyypillinen toimeksiantomme alkaa arkkitehtuurikonsultoinnista — käyttötapauksesi kartoittamisesta oikeisiin agenttimalleihin — jota seuraa prototyyppikehitys ja Cloud Run -käyttöönotto. Olemme havainneet, että tiimit säästävät 2–3 viikkoa saamalla arkkitehtuurin oikein alusta alkaen sen sijaan, että refaktoroisivat myöhemmin.

Rakennatko tekoälyagentteja tiimillesi? Hanki ilmainen konsultaatio — autamme sinua valitsemaan oikean kehyksen ja käyttöönottostrategian.

Yleiset virheet ja vianmääritys

Näitä virheitä kohtaamme useimmin aloittaessamme ADK:lla. Säästä itseltäsi debuggausaika:

Debuggausvinkki: adk web on paras ystäväsi tässä. Se näyttää koko keskustelujäljen — jokaisen mallikutsun, työkalun kutsun ja agentin delegoinnin — reaaliajassa. Kun jokin menee pieleen moniagenttijärjestelmässä, verkkokäyttöliittymä näyttää sinulle täsmälleen, missä kohtaa ketju katkesi.

UKK

Mikä on Google ADK?

Googlen Agent Development Kit (ADK) on avoimen lähdekoodin Python-viitekehys tekoälyagenttien rakentamiseen, arviointiin ja käyttöönottoon. Se on optimoitu Google Gemini -malleille, mutta tukee yli sataa LLM:ää LiteLLM-integraation kautta. ADK:n ydin vahvuus on natiivi moniagenttien orkestrointi sisäänrakennetuilla työkaluilla, kehittäjäkäyttöliittymällä ja yhden komennon Cloud Run -käyttöönotolla.

Onko Google ADK ilmainen käyttää?

Kyllä. ADK itse on avointa lähdekoodia Apache 2.0 -lisenssillä. Tarvitset Gemini API -avaimen, jolla on ilmainen taso, joka tarjoaa 15 pyyntöä minuutissa ja 1 miljoona tokenia päivässä. Pilvikäyttöönoton kustannukset riippuvat hosting-valinnastasi — Cloud Runin ilmainen taso kattaa 2 miljoonaa pyyntöä kuukaudessa.

Mikä on ero Google ADK:n ja LangChainin välillä?

ADK on Googlen mielipiteellinen kehys, joka on optimoitu Geminalle natiivilla moniagenttien orkestroinnilla ja sisäänrakennetuilla käyttöönotto-työkaluilla. LangChain on malliagnostinen laajemmilla kolmannen osapuolen integraatio