Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.

Comece a usar a integração Semantic Kernel Python

Observação

Este tutorial usa a biblioteca Semantic Kernel Python. Para obter um tutorial que usa a biblioteca C#, consulte Introdução à integração C# do Semantic Kernel.

Você pode integrar a Vector Search do MongoDB ao Microsoft Semantic Kernel para criar aplicativos de IA e implementar a geração aumentada de recuperação (RAG). Este tutorial demonstra como começar a usar o MongoDB Vector Search com o Semantic Kernel para executar a pesquisa semântica em seus dados e criar uma implementação de RAG. Especificamente, você executa as seguintes ações:

  1. Configure o ambiente.

  2. Armazene dados personalizados no MongoDB.

  3. Crie um índice do MongoDB Vector Search em seus dados.

  4. Execute uma consulta de pesquisa semântica em seus dados.

  5. Implemente o RAG usando o MongoDB Vector Search para responder a perguntas sobre seus dados.

O Semantic Kernel é um SDK de código aberto que permite combinar vários serviços e plug-ins de IA com seus aplicativos. Você pode usar o Semantic Kernel para uma variedade de casos de uso de IA, incluindo RAG.

Ao integrar o MongoDB pesquisa vetorial com o Semantic Kernel, você pode usar o MongoDB como um banco de dados vetorial e usar o MongoDB pesquisa vetorial para implementar o RAG recuperando documentos semanticamente semelhantes de seus dados. Para aprender mais sobre RAG, consulte Geração aumentada de recuperação (RAG) com MongoDB.

Para concluir este tutorial, você deve ter o seguinte:

  • Um dos seguintes tipos de cluster MongoDB :

    • Um cluster do Atlas executando a versão do MongoDB 6.0.11, 7.0.2, ou posterior. Certifique-se de que seu endereço IP esteja incluído na lista de acesso do seu projeto Atlas.

    • Uma implantação local do Atlas criada usando Python e Docker. Instale atlas-local-lib-py (pip install atlas-local-lib-py) para criar e gerenciar implantações locais programaticamente. Para saber mais, consulte o repositório atlas-local-lib-py.

    • Um cluster MongoDB Community com Search e pesquisa vetorial instalados.

  • Uma chave de API da OpenAI. Você deve ter uma conta da OpenAI com créditos disponíveis para solicitações de API. Para aprender mais sobre como registrar uma conta OpenAI, consulte o website de API OpenAI.

  • Um ambiente para executar blocos de anotações interativos do Python, como o CoLab.

Configure o ambiente para este tutorial. Crie um bloco de anotações Python interativo salvando um arquivo com a extensão .ipynb. Este bloco de anotações permite que você execute trechos de código Python individualmente, e você o usará para executar o código neste tutorial.

Para configurar seu ambiente de bloco de anotações:

1
  1. Execute o seguinte comando no seu bloco de anotações para instalar o kernel semântica no seu ambiente.

    pip install --quiet --upgrade semantic-kernel openai motor
  2. Execute o seguinte código para importar os pacotes necessários:

    import semantic_kernel as skfrom semantic_kernel.connectors.ai.open_ai import (OpenAIChatCompletion, OpenAITextEmbedding)from semantic_kernel.connectors.memory.mongodb_atlas import MongoDBAtlasMemoryStorefrom semantic_kernel.core_plugins.text_memory_plugin import TextMemoryPluginfrom semantic_kernel.memory.semantic_text_memory import SemanticTextMemoryfrom semantic_kernel.prompt_template.input_variable import InputVariablefrom semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfigfrom pymongo import MongoClientfrom pymongo.operations import SearchIndexModel
2

Execute o código a seguir, substituindo os espaços reservados pelos seguintes valores:

  • Sua chave de API da OpenAI.

  • A string de conexão do cluster MongoDB .

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

IMPORTANTE: certifique-se de que a string de conexão inclua as credenciais do usuário de banco de dados. Para aprender mais sobre como localizar sua string de conexão, consulte Conectar-se a um cluster por meio de bibliotecas de clientes.

Nesta seção, você inicializa o kernel, que é a interface principal usada para gerenciar os serviços e plug-ins do seu aplicativo. Por meio do kernel, você configura seus serviços de IA, instancia o MongoDB como um banco de dados vetorial (também chamado de armazenamento de memória) e carrega dados personalizados em seu cluster MongoDB .

Para armazenar dados personalizados no MongoDB, cole e execute os seguintes trechos de código em seu bloco de anotações:

1

Execute o seguinte código para inicializar o kernel.

kernel = sk.Kernel()
2

Execute o código a seguir para configurar o modelo de incorporação OpenAI e o modelo de chat usados neste tutorial e adicionar esses serviços ao kernel. Este código especifica o seguinte:

  • text-embedding-ada-002 da OpenAI como o modelo de incorporação usado para converter texto em incorporações vetoriais.

  • gpt-3.5-turbo do OpenAI como o modelo de chat usado para gerar respostas.

chat_service = OpenAIChatCompletion( service_id="chat", ai_model_id="gpt-3.5-turbo", api_key=OPENAI_API_KEY)embedding_service = OpenAITextEmbedding( ai_model_id="text-embedding-ada-002", api_key=OPENAI_API_KEY)kernel.add_service(chat_service)kernel.add_service(embedding_service)
3

Execute o seguinte código para instanciar o Atlas como um armazenamento de memória e adicioná-lo ao kernel. Este código estabelece uma conexão com seu cluster Atlas e especifica o seguinte:

  • semantic_kernel_db como o banco de dados Atlas usado para armazenar os documentos.

  • vector_index como o índice usado para executar queries semânticas Atlas Search .

Ele também importa um plugin chamado TextMemoryPlugin, que fornece um grupo de funções nativas para ajudá-lo a armazenar e recuperar texto na memória.

mongodb_atlas_memory_store = MongoDBAtlasMemoryStore( connection_string=MONGODB_URI, database_name="semantic_kernel_db", index_name="vector_index") memory = SemanticTextMemory( storage=mongodb_atlas_memory_store, embeddings_generator=embedding_service)kernel.add_plugin(TextMemoryPlugin(memory), "TextMemoryPlugin")
4

Este código define e executa uma função para preencher a coleção semantic_kernel_db.test com alguns documentos de amostra. Esses documentos contêm dados personalizados aos quais o LLM originalmente não tinha acesso.

async def populate_memory(kernel: sk.Kernel) -> None: await memory.save_information( collection="test", id="1", text="I am a developer" ) await memory.save_information( collection="test", id="2", text="I started using MongoDB two years ago" ) await memory.save_information( collection="test", id="3", text="I'm using MongoDB Vector Search with Semantic Kernel to implement RAG" ) await memory.save_information( collection="test", id="4", text="I like coffee" ) print("Populating memory...") await populate_memory(kernel) print(kernel)
Populating memory...plugins=KernelPluginCollection(plugins={'TextMemoryPlugin': KernelPlugin(name='TextMemoryPlugin', description=None, functions={'recall': KernelFunctionFromMethod(metadata=KernelFunctionMetadata(name='recall', plugin_name='TextMemoryPlugin', description='Recall a fact from the long term memory', parameters=[KernelParameterMetadata(name='ask', description='The information to retrieve', default_value=None, type_='str', is_required=True, type_object=<class 'str'>), KernelParameterMetadata(name='collection', description='The collection to search for information.', default_value='generic', type_='str', is_required=False, type_object=<class 'str'>), KernelParameterMetadata(name='relevance', description='The relevance score, from 0.0 to 1.0; 1.0 means perfect match', default_value=0.75, type_='float', is_required=False, type_object=<class 'float'>), KernelParameterMetadata(name='limit', description='The maximum number of relevant memories to recall.', default_value=1, type_='int', is_required=False, type_object=<class 'int'>)], is_prompt=False, is_asynchronous=True, return_parameter=KernelParameterMetadata(name='return', description='', default_value=None, type_='str', is_required=True, type_object=None)), method=<bound method TextMemoryPlugin.recall of TextMemoryPlugin(memory=SemanticTextMemory())>, stream_method=None), 'save': KernelFunctionFromMethod(metadata=KernelFunctionMetadata(name='save', plugin_name='TextMemoryPlugin', description='Save information to semantic memory', parameters=[KernelParameterMetadata(name='text', description='The information to save.', default_value=None, type_='str', is_required=True, type_object=<class 'str'>), KernelParameterMetadata(name='key', description='The unique key to associate with the information.', default_value=None, type_='str', is_required=True, type_object=<class 'str'>), KernelParameterMetadata(name='collection', description='The collection to save the information.', default_value='generic', type_='str', is_required=False, type_object=<class 'str'>)], is_prompt=False, is_asynchronous=True, return_parameter=KernelParameterMetadata(name='return', description='', default_value=None, type_='', is_required=True, type_object=None)), method=<bound method TextMemoryPlugin.save of TextMemoryPlugin(memory=SemanticTextMemory())>, stream_method=None)})}) services={'chat': OpenAIChatCompletion(ai_model_id='gpt-3.5-turbo', service_id='chat', client=<openai.AsyncOpenAI object at 0x7999971c8fa0>, ai_model_type=<OpenAIModelTypes.CHAT: 'chat'>, prompt_tokens=0, completion_tokens=0, total_tokens=0), 'text-embedding-ada-002': OpenAITextEmbedding(ai_model_id='text-embedding-ada-002', service_id='text-embedding-ada-002', client=<openai.AsyncOpenAI object at 0x7999971c8fd0>, ai_model_type=<OpenAIModelTypes.EMBEDDING: 'embedding'>, prompt_tokens=32, completion_tokens=0, total_tokens=32)} ai_service_selector=<semantic_kernel.services.ai_service_selector.AIServiceSelector object at 0x7999971cad70> retry_mechanism=PassThroughWithoutRetry() function_invoking_handlers={} function_invoked_handlers={}

Dica

Depois de executar o código de amostra, se estiver usando o Atlas, poderá verificar suas incorporações vetoriais navegando até o namespace semantic_kernel_db.test na interface do usuário do Atlas.

Para habilitar queries de pesquisa vetorial em seu armazenamento de vetores, execute o seguinte código em seu bloco de anotações para criar um índice do MongoDB Vector Search na coleção semantic_kernel_db.test .

# Connect to your MongoDB cluster and specify the collectionclient = MongoClient(MONGODB_URI)collection = client["semantic_kernel_db"]["test"] # Create your index model, then create the search indexsearch_index_model = SearchIndexModel( definition={ "fields": [ { "type": "vector", "path": "embedding", "numDimensions": 1536, "similarity": "cosine" } ] }, name="vector_index", type="vectorSearch") collection.create_search_index(model=search_index_model)

A definição do índice indexa o campo embedding como o tipo vetor. O campo embedding contém os embeddings criados utilizando o modelo de embedding text-embedding-ada-002 do OpenAI. A definição de índice especifica 1536 dimensões vetoriais e mede a similaridade usando cosine.

Depois que o MongoDB criar seu índice, você poderá executar consultas de pesquisa vetorial em seus dados.

Em seu notebook, execute o código a seguir para realizar uma pesquisa semântica básica pela string What is my job title?. Ele imprime o documento mais relevante e uma pontuação de relevância entre 0 e 1.

result = await memory.search("test", "What is my job title?")print(f"Retrieved document: {result[0].text}, {result[0].relevance}")
Retrieved document: I am a developer, 0.8991971015930176

Esta seção mostra um exemplo de implementação de RAG com o MongoDB Vector Search e o semantic kernel. Agora que você usou a Vector Search do MongoDB para recuperar documentos semanticamente semelhantes, execute o exemplo de código a seguir para solicitar que o LLM responda a perguntas com base nesses documentos.

O código a seguir define um prompt para instruir o LLM a usar o documento recuperado como contexto para sua query. Neste exemplo, você solicita ao LLM com a query de amostra When did I start using MongoDB?. Como você aumentou a base de conhecimento do LLM com dados personalizados, o modelo de chat é capaz de gerar uma resposta mais precisa e com reconhecimento de contexto.

service_id = "chat"settings = kernel.get_service(service_id).instantiate_prompt_execution_settings( service_id=service_id) prompt_template = """ Answer the following question based on the given context. Question: {{$input}} Context: {{$context}}""" chat_prompt_template_config = PromptTemplateConfig( execution_settings=settings, input_variables=[ InputVariable(name="input"), InputVariable(name="context") ], template=prompt_template) prompt = kernel.add_function( function_name="RAG", plugin_name="TextMemoryPlugin", prompt_template_config=chat_prompt_template_config,) question = "When did I start using MongoDB?"results = await memory.search("test", question)retrieved_document = results[0].textanswer = await prompt.invoke( kernel=kernel, input=question, context=retrieved_document)print(answer)
You started using MongoDB two years ago.

O MongoDB também fornece os seguintes recursos para desenvolvedores: