Menu Docs
Página inicial do Docs
/
Atlas
/ / /

Crie agentes de IA com o mecanismo Vertex AI Agent e o Atlas

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.

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.

Antes de começar, verifique se você tem o seguinte:

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.

1

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
2

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.

3

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)

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.

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.

1

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
2

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]
3

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.

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.

1

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",
],
)
2

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
3

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.

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.

Voltar

Extensões do Vertex AI

Próximo

Servidor MCP

Receber um selo de habilidade

Mestre "Gen AI" de grátis!

Saiba mais

Nesta página