La création de systèmes d'IA prêts pour la production nécessite de passer d'une simple invite à une orchestration structurée.. Avec le Kit de développement d'agents Google (ADK) Et pythonVous pouvez créer des agents robustes qui gèrent des raisonnements complexes et la gestion des états.

Dans cet article, je’Je vais vous expliquer les concepts de base de l'ADK: de la définition de votre premier agent à son déploiement en tant qu'API prête pour la production à l'aide de FastAPI.

Qu'est-ce qu'un agent IA?

Contrairement à un LLM standard qui génère simplement du texte en fonction d'une invite, un agent IA comprend les éléments suivants Logique de raisonnement et de décision. Il peut interpréter les demandes des utilisateurs, décider des actions à entreprendre, et interagir avec des outils ou d'autres composants pour accomplir une tâche.
En pratique, un agent peut:

• Raison: Interpréter l'utilisateur’l'intention et comprendre les contraintes de la demande.
• Acte: Appeler des outils externes, Apis, ou des fonctions pour récupérer des informations ou effectuer des opérations.
• Collaborer: Collaborer avec d'autres agents spécialisés pour résoudre des tâches plus complexes.

Cela rend les agents particulièrement utiles pour la construction structuré, applications d'IA en plusieurs étapes.

Notre cas d'utilisation

Dans cet exemple, nous allons créer un Agent de planification de voyages qui peut répondre aux requêtes des utilisateurs sur les voyages et les destinations. L'agent traite l'utilisateur’demande, génère des suggestions de voyage pertinentes et structure utilement la réponse.

Pour rendre le système accessible à d'autres applications, nous exposons l'agent via un API REST construite avec FastAPIqui permet l'intégration avec des applications Web, interfaces de chat et autres services.

Étape 0: Configuration de votre environnement

Pour participer, toi’j'aurai besoin de Python 3.10+ et un gestionnaire de paquets comme pipx ou uv (ce qui est nettement plus rapide que le Pip standard).

Si tu ne’je n'ai pas encore les uv, vous pouvez l'installer avec une simple commande curl:

# Installer UV
boucle -LsSf [https://astral.sh/uv/install.sh](https://astral.sh/uv/install.sh) | merde

Structure du projet

Pour ce projet, nous attendons la structure de projet suivante:

Initialisez votre projet

Une fois UV installé, depuis la racine de votre dépôt, installer les bibliothèques appropriées pour les couches agent et API et activer l'environnement virtuel:

# Installez le GoogleADK, API rapide, et Uvicorne (le serveur ASGI)
uv ajouter google-adk fastapi uvicorn
# Synchronisez les dépendances et activez votre environnement
synchronisation UV
source .venv/bin/activer

L'étape suivante consiste à initialiser votre agent via l'ADK CLI, qui crée la structure de répertoires nécessaire pour votre agent’c'est la logique.

# Créer un nouveau projet d'agent
adk créer my_travel_planner

La configuration .env

La gestion sécurisée des clés API est de la plus haute importance. Vous devez créer un fichier .env dans le répertoire my_travel_planner (ou remplissez le fichier modèle .env existant créé à l'étape ci-dessus) pour gérer les informations d'identification.

Il est important de ne jamais mettre ce fichier sous contrôle de version. Assurez-vous d'ajouter ceci au .fichier gitignore (si c'est le cas’ça n'existe pas déjà).

• Option 1 (Google IA Studio): Si vous utilisez une clé API Gemini standard de Google IA Studiodéfinissez GOOGLE_GENAI_USE_VERTEXAI=False et ajoutez votre clé.
• Option 2 (Sommet AI): Si tu’je suis sur Google Cloud, définissez GOOGLE_GENAI_USE_VERTEXAI=True et référencez les informations d'identification de votre application. Vous pouvez suivre ceci lien pour une documentation précise.

# .modèle d'environnement
GOOGLE_API_KEY=votre_gemini_api_key_here
GOOGLE_GENAI_USE_VERTEXAI=Faux
# Facultatif pour Vertex AI:
# GOOGLE_APPLICATION_CREDENTIALS=chemin/vers/votre/credentials.json

Étape 1: Définir l'agent

Le « cerveau » de votre système est défini dans my_travel_planner/agent.py. Ici, nous donnons un nom à l'agent, un modèle spécifique (comme gemini-2.5-flash) et des instructions claires sur sa personnalité.

à partir de l'agent d'importation google.adk.agents
def get_root_agent():
    # L'agent racine (The "Brain")
    travel_planner = Agent(
        name="travel_planner",
        model="gemini-2.5-flash",
        description="A comprehensive travel planning assistant.",
        instruction="""You are a world-class travel planner.
        Recommend places to visit based on the user's query.""",
    )
    retour travel_planner
root_agent = get_root_agent()

Étape 2: Gérer le stockage avec les sessions et les coureurs

Les LLM apatrides oublient le contexte dès la fin de la demande. Des agents sont requis pour les systèmes de production Mémoire. ADK gère cela via réunions et le coureur.

• Séances: Historique des conversations de l'agent du magasin, informations utilisateur, et statuts intermédiaires.
• Coureur: Orchestre l’ensemble de l’interaction – recevoir des commentaires, le relayer au cerveau, et maintenir l'état.

Ici’voici comment exécuter ce pipeline de manière asynchrone. A la racine de votre dépôt, créer run.py comme ça:

à partir de google.adk.sessions importer InMemorySessionService
à partir de l'agent d'importation google.adk.agents.llm_agent
depuis google.adk.runners importer Runner
à partir des types d'importation google.genai  # Pour créer le contenu/parties du message
importer asyncio
à partir du chemin d'importation pathlib
depuis dotenv importer load_dotenv
load_dotenv(Chemin(__déposer__).mère / "my_travel_planner" / ".env")  # Charger les variables d'environnement à partir du fichier .env
depuis my_travel_planner.agent importer get_root_agent
APP_NAME = "travel-planner_app"
USER_ID = "user_1"
SESSION_ID = "session_001"
asynchrone def setup_session_and_runner(agent_root: Agent = Aucun, id_session: chaîne = SESSION_ID):
    # Installer Runner pour l'exécution
    session_service = InMemorySessionService()
    session = attendre session_service.create_session(nom_application=NOM_APP, user_id = USER_ID, session_id=session_id)
    coureur = coureur(agent=root_agent, nom_application=NOM_APP, session_service=session_service)
    séance de retour, coureur
async def call_agent_async(requête: str, agent_root: Agent = Aucun, id_session: chaîne = SESSION_ID) -> str:
    contenu = types.Contenu(role='user', pièces =[types.Partie(texte = requête)])
    session, coureur = attendre setup_session_and_runner(root_agent=root_agent, session_id=session_id)
    événements = runner.run_async(user_id = USER_ID, session_id=session_id, new_message=contenu)
    final_response_text = "No response received."
    asynchrone pour l'événement dans les événements:
        # Concept clé: is_final_response() marque le message final du tour.
        si event.is_final_response():
            si event.content et event.content.parts:
                final_response_text = event.content.parts[0].texte
            elif event.actions et event.actions.escalate:
                final_response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
            casser
imprimer(f"<<< Réponse de l'agent: {final_response_text}")
    retourner final_response_text
async def run_agent_pipeline(requête: str) -> str:
    root_agent = get_root_agent()
    retour en attente call_agent_async(requête=requête, root_agent=root_agent, session_id=SESSION_ID)
if __name__ == "__main__":
    requête_utilisateur = ("I'm planning a trip to Paris in the spring. Quelles sont les attractions et événements locaux incontournables "
                  "during that time?")
    asyncio.run(run_agent_pipeline(requête = requête_utilisateur))

Étape 3: Transformez votre agent en API

Pour rendre votre agent utile dans le monde réel, nous devons l'exposer en tant qu'API. API rapide est la norme moderne pour cela car il est puissant, utilise des astuces de type pour la validation, et génère automatiquement la documentation Swagger.

En encapsulant notre pipeline ADK dans un point de terminaison POST, nous pouvons connecter notre agent aux frontends, applications mobiles, ou d'autres microservices.

À la racine du référentiel, nous créons api.py, où nous définissons un simple point de terminaison /ask:

à partir de fastapi importer FastAPI
à partir de l'importation pydantique BaseModel
à partir du chemin d'importation pathlib
depuis dotenv importer load_dotenv
load_dotenv(Chemin(__déposer__).mère / "my_travel_planner" / ".env")
depuis l'exécution de l'importation run_agent_pipeline
application = FastAPI(title="Travel Planner AI", description="Powered by Google ADK + Gemini")
classe RequêteRequête(Ce sont des modèles):
    requête: str
classe QueryResponse(Ce sont des modèles):
    requête: str
    réponse: str
@app.post("/ask", réponse_model=Réponse à la requête)
asynchrone def request_agent(demande: RequêteRequête):
    réponse = attendre run_agent_pipeline(requête = requête.query)
    retourner la réponse à la requête(requête = requête.query, réponse=réponse)

Exécutez votre serveur avec: uv exécuter l'API uvicorn:application –recharger
Le serveur démarre à http://hôte local:8000 et documents interactifs (Interface utilisateur Swagger): http://hôte local:8000/documents

Pensées finales: Le chemin vers la production

Un script local est un bon début, mais la mise en production nécessite quelques étapes supplémentaires:

1. Vérifier: Écrire des tests unitaires pour vérifier que la logique de l'agent gère les cas extrêmes.
2. Conteneuriser: Utilisez Docker pour vous assurer que « ça fonctionne sur mon ordinateur » est traduit par « ça fonctionne sur le serveur ».
3. Insérer: Expédiez votre conteneur à un fournisseur de cloud tel que Google Cloud (Exécution en nuage) ou AWS.

Prêt à construire? Obtenez le code du Dépôt GitHub et commencez dès aujourd'hui à créer vos propres workflows d'agents spécialisés!

✨ Nous remercions cela Programmes pour développeurs Google AI/ML Équipe d'assistance pour les crédits Google Cloud.

✨ Le code source est accessible sur GitHub Ici.

✨ Si vous aimez l'article, s'il te plaît s'abonner à mon dernier.
Pour prendre contact, contactez-moi à LinkedIn ou environ ashmibanerjee.com.

Divulgation d'utilisation de GenAI: Des modèles GenAI ont été utilisés pour vérifier le blog pour les incohérences grammaticales et affiner le texte pour plus de clarté.. Les auteurs assument l'entière responsabilité du contenu présenté dans ce blog.

---

[Tutoriel] Des agents aux API: Créer des systèmes d'IA prêts pour la production avec Google ADK & FastAPI a été initialement publié dans Google Developer Experts sur Medium, où les gens poursuivent la discussion en soulignant et en répondant à cette histoire.