Desarrollar y desplegar agentes en Vertex AI Agent Engine

En esta página se muestra cómo crear e implementar un agente que devuelva el tipo de cambio entre dos monedas en una fecha específica. Para ello, se utilizan los siguientes frameworks de agentes:

Antes de empezar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI and Cloud Storage APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI and Cloud Storage APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  8. Para obtener los permisos que necesitas para usar Vertex AI Agent Engine, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en tu proyecto:

    Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

    También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

    Instalar e inicializar el SDK de Vertex AI para Python

    1. Ejecuta el siguiente comando para instalar el SDK de Vertex AI para Python y otros paquetes necesarios:

      ADK

      pip install --upgrade --quiet google-cloud-aiplatform[agent_engines,adk]>=1.112

      LangGraph

      pip install --upgrade --quiet google-cloud-aiplatform[agent_engines,langchain]>=1.112

      LangChain

      pip install --upgrade --quiet google-cloud-aiplatform[agent_engines,langchain]>=1.112

      AG2

      pip install --upgrade --quiet google-cloud-aiplatform[agent_engines,ag2]>=1.112

      LlamaIndex

      pip install --upgrade --quiet google-cloud-aiplatform[agent_engines,llama_index]>=1.112
    2. Autenticarse como usuario

      Colab

      Ejecuta el siguiente código:

      from google.colab import auth
      
      auth.authenticate_user(project_id="PROJECT_ID")
      

      Cloud Shell

      No tienes que hacer nada.

      Shell local

      Ejecuta el siguiente comando:

      gcloud auth application-default login
    3. Ejecuta el siguiente código para importar Vertex AI Agent Engine e inicializar el SDK:

      import vertexai
      
      client = vertexai.Client(
          project="PROJECT_ID",               # Your project ID.
          location="LOCATION",                # Your cloud region.
      )
      

      Donde:

    Desarrollar un agente

    Primero, desarrolla una herramienta:

    def get_exchange_rate(
        currency_from: str = "USD",
        currency_to: str = "EUR",
        currency_date: str = "latest",
    ):
        """Retrieves the exchange rate between two currencies on a specified date."""
        import requests
    
        response = requests.get(
            f"https://api.frankfurter.app/{currency_date}",
            params={"from": currency_from, "to": currency_to},
        )
        return response.json()
    

    A continuación, crea una instancia de un agente:

    ADK

    from google.adk.agents import Agent
    from vertexai import agent_engines
    
    agent = Agent(
        model="gemini-2.0-flash",
        name='currency_exchange_agent',
        tools=[get_exchange_rate],
    )
    
    app = agent_engines.AdkApp(agent=agent)
    

    LangGraph

    from vertexai import agent_engines
    
    agent = agent_engines.LanggraphAgent(
        model="gemini-2.0-flash",
        tools=[get_exchange_rate],
        model_kwargs={
            "temperature": 0.28,
            "max_output_tokens": 1000,
            "top_p": 0.95,
        },
    )
    

    LangChain

    from vertexai import agent_engines
    
    agent = agent_engines.LangchainAgent(
        model="gemini-2.0-flash",
        tools=[get_exchange_rate],
        model_kwargs={
            "temperature": 0.28,
            "max_output_tokens": 1000,
            "top_p": 0.95,
        },
    )
    

    AG2

    from vertexai import agent_engines
    
    agent = agent_engines.AG2Agent(
        model="gemini-2.0-flash",
        runnable_name="Get Exchange Rate Agent",
        tools=[get_exchange_rate],
    )
    

    LlamaIndex

    from vertexai.preview import reasoning_engines
    
    def runnable_with_tools_builder(model, runnable_kwargs=None, **kwargs):
        from llama_index.core.query_pipeline import QueryPipeline
        from llama_index.core.tools import FunctionTool
        from llama_index.core.agent import ReActAgent
    
        llama_index_tools = []
        for tool in runnable_kwargs.get("tools"):
            llama_index_tools.append(FunctionTool.from_defaults(tool))
        agent = ReActAgent.from_tools(llama_index_tools, llm=model, verbose=True)
        return QueryPipeline(modules = {"agent": agent})
    
    agent = reasoning_engines.LlamaIndexQueryPipelineAgent(
        model="gemini-2.0-flash",
        runnable_kwargs={"tools": [get_exchange_rate]},
        runnable_builder=runnable_with_tools_builder,
    )
    

    Por último, prueba el agente de forma local:

    ADK

    async for event in app.async_stream_query(
        user_id="USER_ID",
        message="What is the exchange rate from US dollars to SEK today?",
    ):
        print(event)
    

    donde USER_ID es un ID definido por el usuario con un límite de 128 caracteres.

    LangGraph

    agent.query(input={"messages": [
        ("user", "What is the exchange rate from US dollars to SEK today?"),
    ]})
    

    LangChain

    agent.query(
        input="What is the exchange rate from US dollars to SEK today?"
    )
    

    AG2

    agent.query(
        input="What is the exchange rate from US dollars to SEK today?"
    )
    

    LlamaIndex

    agent.query(
        input="What is the exchange rate from US dollars to SEK today?"
    )
    

    Desplegar un agente

    Para desplegar el agente, sigue estos pasos:

    ADK

    remote_agent = client.agent_engines.create(
        agent=app,
        config={
            "requirements": ["google-cloud-aiplatform[agent_engines,adk]"],
        }
    )
    

    LangGraph

    remote_agent = client.agent_engines.create(
        agent,
        config={
            "requirements": ["google-cloud-aiplatform[agent_engines,langchain]"],
        },
    )
    

    LangChain

    remote_agent = client.agent_engines.create(
        agent,
        config={
            "requirements": ["google-cloud-aiplatform[agent_engines,langchain]"],
        },
    )
    

    AG2

    from vertexai import agent_engines
    
    remote_agent = agent_engines.create(
        agent,
        config={
            "requirements": ["google-cloud-aiplatform[agent_engines,ag2]"],
        },
    )
    

    LlamaIndex

    from vertexai import agent_engines
    
    remote_agent = agent_engines.create(
        agent,
        config={
            "requirements": ["google-cloud-aiplatform[agent_engines,llama_index]"],
        },
    )
    

    De esta forma, se crea un recurso reasoningEngine en Vertex AI.

    Usar un agente

    Prueba el agente implementado enviando una consulta:

    ADK

    async for event in remote_agent.async_stream_query(
        user_id="USER_ID",
        message="What is the exchange rate from US dollars to SEK today?",
    ):
        print(event)
    

    LangGraph

    remote_agent.query(input={"messages": [
        ("user", "What is the exchange rate from US dollars to SEK today?"),
    ]})
    

    LangChain

    remote_agent.query(
        input="What is the exchange rate from US dollars to SEK today?"
    )
    

    AG2

    remote_agent.query(
        input="What is the exchange rate from US dollars to SEK today?"
    )
    

    LlamaIndex

    remote_agent.query(
        input="What is the exchange rate from US dollars to SEK today?"
    )
    

    Limpieza

    Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos utilizados en esta página, sigue estos pasos.

    remote_agent.delete(force=True)
    

    Siguientes pasos