2. Setting Up ADK Agents: CLI, Web, and Programmatic Methods

adk run simple_agent

❯ adk run simple_agent

Log setup complete: /var/folders/.../agent.20251119_051759.log

Running agent root_agent, type exit to exit.

[user]: what is deep learning ?

[root_agent]: Deep learning is a subfield of machine learning...

[user]:

❯ adk run simple_agent --save_session

Running agent root_agent, type exit to exit.

[user]: exit

Session ID to save: demo

Session saved to /path/to/simple_agent/demo.session.json

adk run simple_agent --save_session --session_id demo

adk run simple_agent --resume demo.session.json

adk run simple_agent --replay demo.session.json

adk web

adk web path/to/agents_dir

adk web --port 8080 path/to/agents_dir

adk web --host 0.0.0.0 --port 8000 path/to/agents_dir

adk web --reload path/to/agents_dir

adk web --reload_agents path/to/agents_dir

import asyncio
import os
from google.genai import types
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService

# Load environment variables
from dotenv import load_dotenv
load_dotenv()

async def main():
    # Create session service
    session_service = InMemorySessionService()
    
    # Create a session
    session = await session_service.create_session(
        state={}, 
        app_name='demo_app', 
        user_id='demo_user'
    )
    
    # Create agent
    agent = Agent(
        model=os.getenv("GEMINI_MODEL", "gemini-2.5-flash"),
        name='root_agent',
        description='A helpful assistant for user questions.',
        instruction='Answer user questions to the best of your knowledge',
    )
    
    # Create runner
    runner = Runner(
        app_name='demo_app',
        agent=agent,
        session_service=session_service,
    )
    
    # Format user input
    query = "What is the Transformers in AI?"
    content = types.Content(
        role='user', 
        parts=[types.Part(text=query)]
    )
    
    # Run agent and process events
    events_async = runner.run_async(
        session_id=session.id,
        user_id=session.user_id,
        new_message=content
    )
    
    # Process events and extract response text
    async for event in events_async:
        if event.content and event.content.parts:
            for part in event.content.parts:
                if part.text:
                    print(part.text)

if __name__ == "__main__":
    asyncio.run(main())

# Set API key
export GOOGLE_API_KEY=your_api_key_here

# Run the script
python simple-app.py

The **Transformer** is a groundbreaking neural network architecture introduced in 2017 by Google Brain researchers in their paper "Attention Is All You Need." It has since become the cornerstone of modern Artificial Intelligence, particularly in Natural Language Processing (NLP), but also increasingly in other domains like computer vision.

Here's a breakdown of what makes Transformers revolutionary:

1. **Addressing Limitations of Previous Models (RNNs/LSTMs):**
   Before Transformers, Recurrent Neural Networks (RNNs) and their variants like LSTMs were dominant for sequential data like text. However, they had key drawbacks:
   - **Sequential Processing:** They process data word-by-word, which is slow and hinders parallelization
   - **Difficulty with Long-Range Dependencies:** While LSTMs improved this, they still struggled to effectively capture relationships between words that are far apart

2. **The Core Innovation: The Attention Mechanism:**
   Transformers completely discard recurrence and convolution layers. Instead, they rely entirely on an "attention mechanism" that allows the model to:
   - Weigh the importance of every other word in the input sequence when processing a particular word
   - Dynamically focus on the most relevant parts of the input, regardless of their position

[... rest of the response ...]

pip install fastapi uvicorn python-dotenv

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Optional
import asyncio
import os
from google.genai import types
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from dotenv import load_dotenv

load_dotenv()

app = FastAPI()

# Enable CORS for frontend
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Configure appropriately for production
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Initialize session service and runner
session_service = InMemorySessionService()
agent = Agent(
    model=os.getenv("GEMINI_MODEL", "gemini-2.5-flash"),
    name='root_agent',
    description='A helpful assistant for user questions.',
    instruction='Answer user questions to the best of your knowledge',
)

runner = Runner(
    app_name='custom_frontend_app',
    agent=agent,
    session_service=session_service,
)

# Request/Response models
class ChatRequest(BaseModel):
    message: str
    session_id: Optional[str] = None
    user_id: str = "default_user"

class ChatResponse(BaseModel):
    response: str
    session_id: str

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    try:
        # Create or retrieve session
        if request.session_id:
            session = await session_service.get_session(request.session_id)
            if not session:
                raise HTTPException(status_code=404, detail="Session not found")
        else:
            session = await session_service.create_session(
                state={},
                app_name='custom_frontend_app',
                user_id=request.user_id
            )
        
        # Format user input
        content = types.Content(
            role='user',
            parts=[types.Part(text=request.message)]
        )
        
        # Run agent
        events_async = runner.run_async(
            session_id=session.id,
            user_id=session.user_id,
            new_message=content
        )
        
        # Collect response text
        response_text = ""
        async for event in events_async:
            if event.content and event.content.parts:
                for part in event.content.parts:
                    if part.text:
                        response_text += part.text
        
        return ChatResponse(
            response=response_text,
            session_id=session.id
        )
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health():
    return {"status": "healthy"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8081)

# Set API key
export GOOGLE_API_KEY=your_api_key_here

# Run the server
uvicorn main:app --reload --port 8081

curl -X POST "http://localhost:8081/chat" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "What is the Transformers in AI?",
    "user_id": "test_user"
  }'