Vertex AI Agent Engine é um serviço do Google Cloud Platform que ajuda você a criar e escalar agentes de IA na produção. Você pode usar o Agent Engine com o MongoDB Atlas e sua estrutura preferida para criar agentes de IA para uma variedade de casos de uso, incluindo RAG agente.
Começar
O tutorial seguinte demonstra como você pode utilizar o Mecanismo de Agente com Atlas para construir um agente RAG que pode responder perguntas sobre dados de amostra. Ele usa o MongoDB Vector Search com LangChain para implementar a recuperação FERRAMENTAS para o agente.
Pré-requisitos
Antes de começar, verifique se você tem o seguinte:
Um Atlas cluster na sua região preferida do Google Cloud Platform. Para criar um novo cluster, consulte Criar um cluster. Você também pode começar a usar o Atlas por meio do Google Cloud Platform Marketplace.
Um projeto do Google Cloud com o Vertex AI habilitado. Para configurar um projeto, consulte Configurar um projeto e um ambiente de desenvolvimento na documentação do Google Cloud.
Configure seu ambiente
Crie um notebook interativo Python salvando um arquivo com a extensão .ipynb
no Google Colab. Esse notebook permite que você execute trechos de código Python individualmente, e você o usará para executar o código neste tutorial.
Instale os pacotes necessários.
No seu ambiente de notebook, instale os pacotes necessários:
!pip install --upgrade --quiet \ "google-cloud-aiplatform[langchain,agent_engines]" requests datasets pymongo langchain langchain-community langchain-mongodb langchain-google-vertexai google-cloud-aiplatform langchain_google_genai requests beautifulsoup4
Crie os índices do MongoDB Vector Search .
Execute o código a seguir em seu bloco de anotações para criar as coleções do MongoDB e os índices do MongoDB Vector Search usados para armazenar e consultar seus dados para este tutorial. Substitua <connection-string>
pela string de conexãodo seu cluster.
Observação
Substitua <connection-string>
pela string de conexão do seu cluster do Atlas ou da implantação local do Atlas.
Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net
Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true
Para saber mais, consulte Connection strings.
from pymongo import MongoClient from pymongo.operations import SearchIndexModel client = MongoClient("<connection-string>") # Replace with your connection string db = client["AGENT-ENGINE"] stars_wars_collection = db["sample_starwars_embeddings"] stars_trek_collection = db["sample_startrek_embeddings"] # Create your index model, then create the search index search_index_model = SearchIndexModel( definition={ "fields": [ { "type": "vector", "path": "embedding", "numDimensions": 768, "similarity": "cosine" } ] }, name="vector_index", type="vectorSearch" ) # Create the indexes stars_wars_collection.create_search_index(model=search_index_model) stars_trek_collection.create_search_index(model=search_index_model)
Para saber mais sobre como criar um índice do MongoDB Vector Search, consulte Como indexar campos para o Vector Search.
Inicialize o Vertex AI SDK.
Execute o seguinte código no seu notebook, substituindo os valores de espaço reservado pelo ID do seu projeto Google Cloud, região e bucket de estágio:
PROJECT_ID = "<your-project-id>" # Replace with your project ID LOCATION = "<gcp-region>" # Replace with your preferred region, e.g. "us-central1" STAGING_BUCKET = "gs://<your-bucket-name>" # Replace with your bucket import vertexai vertexai.init(project=PROJECT_ID, location=LOCATION, staging_bucket=STAGING_BUCKET)
Ingerir dados no Atlas
Execute o código a seguir para extrair dados de amostra da Wikipedia sobre Star Wars e Star Trek, converter o texto em embeddings vetoriais usando o modelo text-embedding-005
e, em seguida, armazenar esses dados nas coleções correspondentes no Atlas.
import requests from bs4 import BeautifulSoup from pymongo import MongoClient import certifi from vertexai.language_models import TextEmbeddingModel # Scrape the website content def scrape_website(url): response = requests.get(url) soup = BeautifulSoup(response.text, 'html.parser') content = ' '.join([p.text for p in soup.find_all('p')]) return content # Split the content into chunks of 1000 characters def split_into_chunks(text, chunk_size=1000): return [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)] def get_text_embeddings(chunks): model = TextEmbeddingModel.from_pretrained("text-embedding-005") embeddings = model.get_embeddings(chunks) return [embedding.values for embedding in embeddings] def write_to_mongoDB(embeddings, chunks, db_name, coll_name): client = MongoClient("<connection-string>", tlsCAFile=certifi.where()) # Replace placeholder with your Atlas connection string db = client[db_name] collection = db[coll_name] for i in range(len(chunks)): collection.insert_one({ "chunk": chunks[i], "embedding": embeddings[i] }) # Process Star Wars data content = scrape_website("https://en.wikipedia.org/wiki/Star_Wars") chunks = split_into_chunks(content) embeddings_starwars = get_text_embeddings(chunks) write_to_mongoDB(embeddings_starwars, chunks, "AGENT-ENGINE", "sample_starwars_embeddings") # Process Star Trek data content = scrape_website("https://en.wikipedia.org/wiki/Star_Trek") chunks = split_into_chunks(content) embeddings_startrek = get_text_embeddings(chunks) write_to_mongoDB(embeddings_startrek, chunks, "AGENT-ENGINE", "sample_startrek_embeddings")
Dica
Você pode visualizar seus dados na interface do Atlas navegando até o banco de dados AGENT-ENGINE
e selecionando as coleções sample_starwars_embeddings
e sample_startrek_embeddings
.
Crie o agente
Nesta seção, você define FERRAMENTAS que o agente pode usar para consultar suas coleções usando o MongoDB Vector Search, criar um sistema de memória para manter o contexto da conversa e, em seguida, inicializar o agente usando o LangChain.
Defina as ferramentas para o agente.
Criar as seguintes duas ferramentas:
Execute o seguinte código para criar uma ferramenta que utiliza MongoDB Vector Search para consultar a coleção sample_starwars_embeddings
:
def star_wars_query_tool( query: str ): """ Retrieves vectors from a MongoDB database and uses them to answer a question related to Star wars. Args: query: The question to be answered about star wars. Returns: A dictionary containing the response to the question. """ from langchain.chains import ConversationalRetrievalChain, RetrievalQA from langchain_mongodb import MongoDBAtlasVectorSearch from langchain_google_vertexai import VertexAIEmbeddings, ChatVertexAI from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory from langchain.prompts import PromptTemplate prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer. Do not return any answers from your own knowledge. Respond only in 2 or 3 sentences. {context} Question: {question} """ PROMPT = PromptTemplate( template=prompt_template, input_variables=["context", "question"] ) # Replace with your connection string to your Atlas cluster connection_string = "<connection-string>" embeddings = VertexAIEmbeddings(model_name="text-embedding-005") vs = MongoDBAtlasVectorSearch.from_connection_string( connection_string=connection_string, namespace="AGENT-ENGINE.sample_starwars_embeddings", embedding=embeddings, index_name="vector_index", embedding_key="embedding", text_key="chunk", ) llm = ChatVertexAI( model_name="gemini-pro", convert_system_message_to_human=True, max_output_tokens=1000, ) retriever = vs.as_retriever( search_type="mmr", search_kwargs={"k": 10, "lambda_mult": 0.25} ) memory = ConversationBufferWindowMemory( memory_key="chat_history", k=5, return_messages=True ) conversation_chain = ConversationalRetrievalChain.from_llm( llm=llm, retriever=retriever, memory=memory, combine_docs_chain_kwargs={"prompt": PROMPT}, ) response = conversation_chain({"question": query}) return response
Execute o seguinte código para criar uma ferramenta que utiliza MongoDB Vector Search para consultar a coleção sample_startrek_embeddings
:
def star_trek_query_tool( query: str ): """ Retrieves vectors from a MongoDB database and uses them to answer a question related to star trek. Args: query: The question to be answered about star trek. Returns: A dictionary containing the response to the question. """ from langchain.chains import ConversationalRetrievalChain, RetrievalQA from langchain_mongodb import MongoDBAtlasVectorSearch from langchain_google_vertexai import VertexAIEmbeddings, ChatVertexAI from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory from langchain.prompts import PromptTemplate prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer. Do not return any answers from your own knowledge. Respond only in 2 or 3 sentences. {context} Question: {question} """ PROMPT = PromptTemplate( template=prompt_template, input_variables=["context", "question"] ) # Replace with your connection string to your Atlas cluster connection_string = "<connection-string>" embeddings = VertexAIEmbeddings(model_name="text-embedding-005") vs = MongoDBAtlasVectorSearch.from_connection_string( connection_string=connection_string, namespace="AGENT-ENGINE.sample_startrek_embeddings", embedding=embeddings, index_name="vector_index", embedding_key="embedding", text_key="chunk", ) llm = ChatVertexAI( model_name="gemini-pro", convert_system_message_to_human=True, max_output_tokens=1000, ) retriever = vs.as_retriever( search_type="mmr", search_kwargs={"k": 10, "lambda_mult": 0.25} ) memory = ConversationBufferWindowMemory( memory_key="chat_history", k=5, return_messages=True ) conversation_chain = ConversationalRetrievalChain.from_llm( llm=llm, retriever=retriever, memory=memory, combine_docs_chain_kwargs={"prompt": PROMPT}, ) response = conversation_chain({"question": query}) return response
Crie um sistema de memória.
Você pode usar o LangChain para criar memória para o seu agente, permitindo que ele mantenha o contexto da conversa em vários prompts:
from langchain.memory import ChatMessageHistory # Initialize session history store = {} def get_session_history(session_id: str): if session_id not in store: store[session_id] = ChatMessageHistory() return store[session_id]
Inicie o agente.
Crie o agente usando LangChain. Esse agente utiliza as ferramentas e o sistema de memória que você definiu.
from vertexai.preview.reasoning_engines import LangchainAgent # Specify the language model model = "gemini-1.5-pro-001" # Initialize the agent with your tools agent = LangchainAgent( model=model, chat_history=get_session_history, model_kwargs={"temperature": 0}, tools=[star_wars_query_tool, star_trek_query_tool], agent_executor_kwargs={"return_intermediate_steps": True}, )
Para testar o agente com uma consulta de amostra:
# Test your agent response = agent.query( input="Who was the antagonist in Star wars and who played them? ", config={"configurable": {"session_id": "demo"}}, ) display(Markdown(response["output"]))
The main antagonist in the Star Wars series is Darth Vader, a dark lord of the Sith. He was originally played by David Prowse in the original trilogy, and later voiced by James Earl Jones. In the prequel trilogy, he appears as Anakin Skywalker, and was played by Hayden Christensen.
Implantar o Agente
Nesta seção, você implanta seu agente no mecanismo de agentes do Vertex AI como um serviço gerenciado. Isso permite que você escale seu agente e o utilize em produção sem precisar gerenciar a infraestrutura subjacente.
Implemente seu agente.
Execute o seguinte código para configurar e implantar o agente no Vertex AI Agent Engine:
from vertexai import agent_engines remote_agent = agent_engines.create( agent, requirements=[ "google-cloud-aiplatform[agent_engines,langchain]", "cloudpickle==3.0.0", "pydantic>=2.10", "requests", "langchain-mongodb", "pymongo", "langchain-google-vertexai", ], )
Recuperar o URL do projeto.
Execute o código a seguir para recuperar o número do projeto associado ao seu ID do grupo. Este número de projeto será utilizado para construir o nome completo do recurso para o seu agente implantado:
from googleapiclient import discovery from IPython.display import display, Markdown # Retrieve the project number associated with your project ID service = discovery.build("cloudresourcemanager", "v1") request = service.projects().get(projectId=PROJECT_ID) response = request.execute() project_number = response["projectNumber"] print(f"Project Number: {project_number}") # The deployment creates a unique ID for your agent that you can find in the output
Teste o agente.
Execute o seguinte código para usar seu agente. Substitua o espaço reservado pelo nome completo do recurso do seu agente:
Observação
Após a implantação, seu agente terá um nome de recurso exclusivo no seguinte formato:
projects/<project-number>/locations/<gcp-region>/reasoningEngines/<unique-id>
from vertexai.preview import reasoning_engines # Replace with your agent's full resource name from the previous step REASONING_ENGINE_RESOURCE_NAME = "<resource-name>" remote_agent = reasoning_engines.ReasoningEngine(REASONING_ENGINE_RESOURCE_NAME) response = remote_agent.query( input="tell me about episode 1 of star wars", config={"configurable": {"session_id": "demo"}}, ) print(response["output"]) response = remote_agent.query( input="Who was the main character in this series", config={"configurable": {"session_id": "demo"}}, ) print(response["output"])
Star Wars: Episode I - The Phantom Menace was the first film installment released as part of the prequel trilogy. It was released on May 19, 1999. The main plot lines involve the return of Darth Sidious, the Jedi's discovery of young Anakin Skywalker, and the invasion of Naboo by the Trade Federation. The main character in Star Wars is Luke Skywalker. He is a young farm boy who dreams of adventure and becomes a Jedi Knight. He fights against the evil Galactic Empire alongside his friends, Princess Leia and Han Solo.
Você também pode perguntar ao agente sobre Star Trek usando a mesma sessão:
response = remote_agent.query( input="what is episode 1 of star trek?", config={"configurable": {"session_id": "demo"}}, ) print(response["output"])
Episode 1 of Star Trek is called "The Man Trap". It was first aired on September 8, 1966. The story involves the Enterprise crew investigating the disappearance of a crew on a scientific outpost. It turns out that the crew members were killed by a creature that can take on someone else's form after it kills them.
Próximos passos
Você também pode depurar e otimizar seus agentes ativando o rastreamento no Mecanismo do Agente. Consulte a documentação do mecanismo do agente Vertex AI para outros recursos e exemplos.
Para saber mais sobre a integração do MongoDB com o MongoDB, consulte Integrar o MongoDB com o LangChain.