LangChain and Zilliz Cloud Integration

LangChain é um framework de código aberto para criar agentes e aplicações com tecnologia de LLM. Ele fornece uma arquitetura de agente pré-construída e integrações para modelos e ferramentas, facilitando a conexão com provedores como OpenAI, Anthropic e Google e permitindo começar a criar rapidamente. O LangChain foi projetado para ser fácil de usar, mantendo flexibilidade suficiente para fluxos de trabalho personalizados, e seus agentes são construídos sobre o LangGraph para capacidades como execução durável, streaming, persistência e suporte com humano no circuito.

Ao integrar o Zilliz Cloud (Milvus totalmente gerenciado) com o LangChain, você pode adicionar busca e recuperação vetorial de alto desempenho às suas aplicações de LLM, facilitando a criação de pipelines RAG, agentes e fluxos de trabalho de IA sensíveis ao contexto sobre seus próprios dados.

• Facilita a criação de aplicações de LLM que usam conhecimento externo, ferramentas e recuperação, sem precisar juntar manualmente cada componente.
• Usa LangChain para orquestrar prompts, chains e fluxos de recuperação dentro da aplicação.
• Usa Zilliz Cloud (Milvus gerenciado) como a camada de banco de dados vetorial para armazenar embeddings e executar busca semântica nos seus dados.
• Funciona especialmente bem para cargas de trabalho de RAG e perguntas e respostas sobre documentos, em que informações relevantes precisam ser recuperadas dinamicamente para melhorar a qualidade das respostas.
• Permite que os desenvolvedores se concentrem mais na lógica da aplicação e menos no gerenciamento da infraestrutura vetorial e dos sistemas de recuperação.

LangChain serve como uma estrutura para desenvolver aplicações baseadas em modelos de linguagem. Ele ajuda a conectar modelos de linguagem a fontes contextuais, como instruções de prompt, exemplos few-shot, ferramentas externas e conteúdo relevante armazenado em bancos de dados vetoriais. Isso torna as aplicações mais conscientes do contexto e mais capazes de gerar respostas fundamentadas nas informações corretas. O LangChain também possibilita fluxos de trabalho orientados por raciocínio, permitindo que as aplicações decidam como responder com base no contexto disponível e quais ações executar em seguida. Com seus componentes modulares e chains prontas para uso, os desenvolvedores podem montar rapidamente fluxos de trabalho comuns de LLM ou personalizá-los para aplicações mais complexas.

Zilliz Cloud, a versão totalmente gerenciada do Milvus, fornece a camada de banco de dados vetorial para armazenar, indexar e recuperar embeddings em escala. Quando os dados da aplicação são convertidos em vetores, o Zilliz Cloud possibilita executar buscas rápidas por similaridade e retornar o conteúdo mais relevante para uma determinada consulta. Isso dá às aplicações LangChain uma maneira confiável de buscar conhecimento externo e usá-lo como contexto durante a geração.

Juntos, o LangChain e o Zilliz Cloud facilitam a criação de aplicações de LLM conscientes do contexto e fluxos de trabalho de geração aumentada por recuperação. O LangChain gerencia a lógica da aplicação, as chains e o fluxo de raciocínio, enquanto o Zilliz Cloud fornece recuperação de alto desempenho sobre seus dados. Essa combinação ajuda os desenvolvedores a criar aplicações de IA que podem acessar conhecimento relevante, responder com melhor fundamentação e escalar de forma mais eficaz em produção.

1. Instale os pacotes necessários

Comece instalando a integração LangChain Milvus, o Milvus Lite e o pacote de integração OpenAI. A documentação do Milvus usa essa configuração para desenvolvimento local e prototipagem. (Milvus)

pip install -qU langchain-milvus milvus-lite langchain-openai

O Milvus Lite está incluído na versão mais recente do pymilvus e armazena tudo em um arquivo local, o que o torna uma opção simples para começar. Para cargas de trabalho em maior escala, a documentação recomenda executar um servidor Milvus completo em vez disso. (Milvus)

2.Inicialize embeddings e conecte-se ao Milvus

Em seguida, crie seu modelo de embedding e inicialize o armazenamento vetorial Milvus. No exemplo oficial, os embeddings são gerados com OpenAIEmbeddings(model="text-embedding-3-large"), e o armazenamento vetorial aponta para um arquivo .db local por meio do Milvus Lite. A mesma interface também pode se conectar a um servidor Milvus em execução substituindo o URI local por um endereço de servidor, como http://localhost:19530. (Milvus)

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

from langchain_milvus import Milvus

# The easiest way is to use Milvus Lite where everything is stored in a local file.
# If you have a Milvus server you can use the server URI such as "http://localhost:19530".
URI = "./milvus_example.db"

vector_store = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": URI},
)

3.Organize os dados com collections

O Milvus oferece suporte ao armazenamento de conjuntos de dados não relacionados em diferentes collections dentro da mesma instância do Milvus. Isso ajuda a manter os contextos separados e torna o armazenamento vetorial mais fácil de gerenciar. A documentação primeiro mostra como criar uma collection a partir de documentos e, depois, como carregar essa mesma collection novamente pelo nome. (Milvus)

from langchain_core.documents import Document

vector_store_saved = Milvus.from_documents(
    [Document(page_content="foo!")],
    embeddings,
    collection_name="langchain_example",
    connection_args={"uri": URI},
)

vector_store_loaded = Milvus(
    embeddings,
    connection_args={"uri": URI},
    collection_name="langchain_example",
)

4.Adicione documentos ao armazenamento vetorial

Depois que o armazenamento vetorial estiver pronto, você pode inserir documentos com add_documents. O tutorial oficial usa dez documentos de exemplo e atribui um UUID a cada um antes de inseri-los. Metadados como "source": "tweet" ou "source": "news" são armazenados junto com cada documento e podem ser usados posteriormente para filtragem durante a busca. (Milvus)

from uuid import uuid4

from langchain_core.documents import Document

document_1 = Document(
    page_content="I had chocalate chip pancakes and scrambled eggs for breakfast this morning.",
    metadata={"source": "tweet"},
)
document_2 = Document(
    page_content="The weather forecast for tomorrow is cloudy and overcast, with a high of 62 degrees.",
    metadata={"source": "news"},
)

document_3 = Document(
    page_content="Building an exciting new project with LangChain - come check it out!",
    metadata={"source": "tweet"},
)

document_4 = Document(
    page_content="Robbers broke into the city bank and stole $1 million in cash.",
    metadata={"source": "news"},
)
document_5 = Document(
    page_content="Wow! That was an amazing movie. I can't wait to see it again.",
    metadata={"source": "tweet"},
)

document_6 = Document(
    page_content="Is the new iPhone worth the price? Read this review to find out.",
    metadata={"source": "website"},
)

document_7 = Document(
    page_content="The top 10 soccer players in the world right now.",
    metadata={"source": "website"},
)
document_8 = Document(
    page_content="LangGraph is the best framework for building stateful, agentic applications!",
    metadata={"source": "tweet"},
)

document_9 = Document(
    page_content="The stock market is down 500 points today due to fears of a recession.",
    metadata={"source": "news"},
)

document_10 = Document(
    page_content="I have a bad feeling I am going to get deleted :(",
    metadata={"source": "tweet"},
)

documents = [
    document_1,
    document_2,
    document_3,
    document_4,
    document_5,
    document_6,
    document_7,
    document_8,
    document_9,
    document_10,
]

uuids = [str(uuid4()) for _ in range(len(documents))]

vector_store.add_documents(documents=documents, ids=uuids)

5.Exclua documentos quando necessário

O tutorial também mostra como remover documentos por ID. Isso é útil quando os registros ficam desatualizados ou precisam ser atualizados por meio de um fluxo de trabalho de exclusão e reinserção. No exemplo abaixo, o último documento inserido é excluído usando seu UUID. (Milvus)

vector_store.delete(ids=[uuids[-1]])

6. Execute uma busca por similaridade

Depois que os documentos são armazenados, você pode consultar o armazenamento vetorial diretamente. O exemplo básico usa similarity_search() com k=2 e uma expressão de filtro de metadados, expr='source == "tweet"', para pesquisar apenas entre documentos semelhantes a tweets. Isso mostra que LangChain + Milvus oferece suporte tanto à similaridade vetorial quanto à filtragem estruturada na mesma consulta. (Milvus)

results = vector_store.similarity_search(
    "LangChain provides abstractions to make working with LLMs easy",
    k=2,
    expr='source == "tweet"',
    # param=...  # Search params for the index type
)

for res in results:
    print(f"* {res.page_content} [{res.metadata}]")

Exemplo de saída da documentação:

* Building an exciting new project with LangChain - come check it out! [{'source': 'tweet', 'pk': 'e991a253-5f37-46ae-850a-82a660e33013'}]
* LangGraph is the best framework for building stateful, agentic applications! [{'source': 'tweet', 'pk': 'eb149e29-239a-4e2c-9f99-751cb7207abf'}]

7. Pesquise com pontuações de similaridade

Se você também quiser a pontuação de similaridade, use similarity_search_with_score(). O exemplo oficial consulta conteúdo relacionado ao clima e filtra para documentos "news". Isso é útil quando você quer inspecionar a qualidade do ranqueamento ou decidir como definir um limite para os resultados de recuperação antes de passá-los para um LLM. (Milvus)

results = vector_store.similarity_search_with_score(
    "Will it be hot tomorrow?", k=1, expr='source == "news"'
)

for res, score in results:
    print(f"* [SIM={score:3f}] {res.page_content} [{res.metadata}]")

Exemplo de saída da documentação:

* [SIM=0.893776] The weather forecast for tomorrow is cloudy and overcast, with a high of 62 degrees. [{'source': 'news', 'pk': 'dbf6560a-1487-4a6e-8797-245d57874f5b'}]

8. Transforme o armazenamento vetorial em um recuperador

Para a maioria das aplicações LangChain, especialmente pipelines RAG, geralmente é mais conveniente converter o armazenamento vetorial em um recuperador. A documentação mostra isso com as_retriever(search_type="mmr", search_kwargs={"k": 1}). Depois de convertido, você pode chamar invoke() e ainda aplicar filtros de metadados por meio de expr. (Milvus)

retriever = vector_store.as_retriever(search_type="mmr", search_kwargs={"k": 1})
retriever.invoke("Stealing from the bank is a crime", expr='source == "news"')

Exemplo de saída da documentação:

[Document(metadata={'source': 'news', 'pk': '2818c051-5a1a-44cb-9deb-aaaac709f616'}, page_content='Robbers broke into the city bank and stole $1 million in cash.')]

Este é o ponto em que a integração se torna especialmente útil para cadeias e agentes downstream, porque recuperadores se integram naturalmente a fluxos de trabalho LangChain maiores. (Milvus)

9. Use chaves de partição para recuperação por usuário

Se a sua aplicação atende a vários usuários, a documentação do Milvus recomenda usar partition_key para multilocação, de modo que os usuários recuperem apenas seus próprios dados. O exemplo usa um campo namespace como chave de partição e, em seguida, filtra a recuperação com expressões como namespace == "ankush". A documentação também observa que a chave de partição não está disponível no Milvus Lite, portanto esta parte requer um servidor Milvus em execução por meio de Docker ou Kubernetes. (Milvus)

from langchain_core.documents import Document

docs = [
    Document(page_content="i worked at kensho", metadata={"namespace": "harrison"}),
    Document(page_content="i worked at facebook", metadata={"namespace": "ankush"}),
]

vectorstore = Milvus.from_documents(
    docs,
    embeddings,
    collection_name="partitioned_collection",  # Use a different collection name
    connection_args={"uri": URI},
    # drop_old=True,
    partition_key_field="namespace",  # Use the "namespace" field as the partition key
)

Para pesquisar com a chave de partição, inclua-a na expressão booleana:

search_kwargs={"expr": '<partition_key> == "xxxx"'}

ou

search_kwargs={"expr": '<partition_key> == in ["xxx", "xxx"]'}

Substitua <partition_key> pelo nome real do campo que você designou como chave de partição. O Milvus então filtra as entidades por chave de partição antes de pesquisar. (Milvus)

Exemplos de recuperações da documentação:

# This will only get documents for Ankush
vectorstore.as_retriever(search_kwargs={"expr": 'namespace == "ankush"'}).invoke(
    "where did i work?"
)

[Document(metadata={'namespace': 'ankush', 'pk': 460829372217788296}, page_content='i worked at facebook')]

# This will only get documents for Harrison
vectorstore.as_retriever(search_kwargs={"expr": 'namespace == "harrison"'}).invoke(
    "where did i work?"
)

[Document(metadata={'namespace': 'harrison', 'pk': 460829372217788295}, page_content='i worked at kensho')]

• Tutorial | Comece a usar LangChain e Milvus
• Tutorial | Guia definitivo para começar a usar LangChain
• Tutorial | Usando LangChain para fazer autoconsulta em um banco de dados vetorial
• Vídeo com Harrison Chase | Memória para aplicações de LLM: diferentes técnicas de recuperação para obter o contexto mais relevante
• Vídeos curtos com Yujian Tang | Como adicionar memória conversacional a um LLM usando LangChain
• Vídeo com Lance Martin | Depurando seus apps de RAG com LangSmith