Cómo Crear tu PRIMER Agente de IA con Google ADK

# Crear entorno virtual
python -m venv .venv

# Activarlo en macOS / Linux
source .venv/bin/activate

# Windows PowerShell
# .venv\Scripts\Activate.ps1

# Instalar Google ADK
pip install -U google-adk

# Crear estructura inicial
mkdir mi-primer-agente
cd mi-primer-agente

from google.adk.agents import Agent


MODEL = "gemini-3.7-flash"


def get_customer_status(customer_id: str) -> str:
    """Return the current status of a customer.

    Args:
        customer_id: Unique identifier of the customer.

    Returns:
        A human-readable customer status.
    """
    # Sustituir por una llamada real a tu backend.
    fake_database = {
        "C001": "ACTIVE",
        "C002": "SUSPENDED",
    }

    return fake_database.get(customer_id, "NOT_FOUND")


root_agent = Agent(
    name="customer_support_agent",
    model=MODEL,
    instruction="""
    You are a customer support agent.

    Rules:
    - Be concise and factual.
    - Never invent customer information.
    - Use get_customer_status when the user asks about
      the status of a specific customer.
    - If the customer ID is missing, ask for it.
    """,
    tools=[get_customer_status],
)

from dataclasses import dataclass


@dataclass(frozen=True)
class RefundResult:
    success: bool
    message: str
    refund_id: str | None = None


def create_refund_request(
    order_id: str,
    amount_eur: float,
    reason: str,
) -> dict:
    """Create a refund request for an order.

    Args:
        order_id: Existing order identifier.
        amount_eur: Refund amount in EUR.
        reason: Business reason for the refund.

    Returns:
        Structured result describing the operation.
    """

    # 1. Validate input at the tool boundary.
    if not order_id.strip():
        return {
            "success": False,
            "message": "order_id is required",
        }

    if amount_eur <= 0:
        return {
            "success": False,
            "message": "amount_eur must be greater than zero",
        }

    if amount_eur > 500:
        return {
            "success": False,
            "message": "Refund exceeds automatic approval limit",
        }

    # 2. Here you would call your transactional backend.
    # Never let the LLM directly manipulate the database.

    refund_id = "RF-2026-000123"

    # 3. Return a small, explicit result to the model.
    return {
        "success": True,
        "refund_id": refund_id,
        "message": "Refund request created successfully",
    }

import os

from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm


def build_model():
    """Select the model through configuration, not business logic."""

    provider = os.getenv("MODEL_PROVIDER", "gemini")

    if provider == "gemini":
        return os.getenv("GEMINI_MODEL", "gemini-3.7-flash")

    if provider == "openai":
        return LiteLlm(
            model=os.getenv("OPENAI_MODEL", "openai/gpt-4o")
        )

    if provider == "anthropic":
        return LiteLlm(
            model=os.getenv(
                "ANTHROPIC_MODEL",
                "anthropic/claude-sonnet-4-20250514"
            )
        )

    raise ValueError(
        f"Unsupported MODEL_PROVIDER: {provider}"
    )


root_agent = Agent(
    name="multi_model_agent",
    model=build_model(),
    instruction="""
    You are a production AI assistant.

    Use available tools when external data is required.
    Never fabricate tool results.
    Keep responses concise and factual.
    """,
    tools=[],
)