Sign inSign upContact us

Integração com LangChain

Aprenda como integrar o Rememberizer como um recuperador LangChain para fornecer ao seu aplicativo LangChain acesso a uma poderosa busca em banco de dados vetorial.

Integração LangChain

O Rememberizer se integra ao LangChain através da classe RememberizerRetriever, permitindo que você incorpore facilmente as capacidades de busca semântica do Rememberizer em suas aplicações alimentadas pelo LangChain. Este guia explica como configurar e usar essa integração para construir aplicações LLM avançadas com acesso à sua base de conhecimento.

Introdução

LangChain é um framework popular para construir aplicações com grandes modelos de linguagem (LLMs). Ao integrar o Rememberizer com o LangChain, você pode:

  • Usar sua base de conhecimento do Rememberizer em aplicações RAG (Geração Aumentada por Recuperação)

  • Criar chatbots com acesso aos seus documentos e dados

  • Construir sistemas de perguntas e respostas que aproveitam seu conhecimento

  • Desenvolver agentes que podem pesquisar e raciocinar sobre suas informações

A integração está disponível no módulo langchain_community.retrievers.

LogoRememberizer | 🦜️🔗 LangChain

Começando

Pré-requisitos

Antes de começar, você precisa:

  1. Uma conta Rememberizer com Conhecimento Comum criada

  2. Uma chave de API para acessar seu Conhecimento Comum

  3. Ambiente Python com LangChain instalado

Para instruções detalhadas sobre como criar Conhecimento Comum e gerar uma chave de API, veja Registrando e Usando Chaves de API.

Instalação

Instale os pacotes necessários:

pip install langchain langchain_community

Se você planeja usar modelos OpenAI (como mostrado nos exemplos abaixo):

pip install langchain_openai

Configuração de Autenticação

Existem duas maneiras de autenticar o RememberizerRetriever:

  1. Variável de Ambiente: Defina a variável de ambiente REMEMBERIZER_API_KEY

    import os
os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"

  2. Parâmetro Direto: Passe a chave da API diretamente ao inicializar o recuperador

    retriever = RememberizerRetriever(rememberizer_api_key="rem_ck_your_api_key")

Opções de Configuração

A classe RememberizerRetriever aceita estes parâmetros:

Parâmetro
Tipo
Padrão
Descrição

top_k_results

int

10

Número de documentos a retornar da busca

rememberizer_api_key

str

None

Chave da API para autenticação (opcional se definida como variável de ambiente)

Nos bastidores, o recuperador faz chamadas de API para o endpoint de busca do Rememberizer com parâmetros configuráveis adicionais:

Parâmetro Avançado
Descrição

prev_chunks

Número de partes antes da parte correspondente a incluir (padrão: 2)

next_chunks

Número de partes após a parte correspondente a incluir (padrão: 2)

return_full_content

Se deve retornar o conteúdo completo do documento (padrão: true)

Uso Básico

Aqui está um exemplo simples de recuperação de documentos do Rememberizer usando LangChain:

import os
from langchain_community.retrievers import RememberizerRetriever

Defina sua chave de API

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"

Inicializar o recuperador

retriever = RememberizerRetriever(top_k_results=5)

Obter documentos relevantes para uma consulta

docs = retriever.get_relevant_documents(query="Como funcionam as incorporações vetoriais?")

Exibir o primeiro documento

if docs: print(f"Documento: {docs[0].metadata['name']}") print(f"Conteúdo: {docs[0].page_content[:200]}...")


### Compreendendo a Estrutura do Documento

Cada documento retornado pelo recuperador possui:

- `page_content`: O conteúdo textual do trecho do documento correspondente
- `metadata`: Informações adicionais sobre o documento

Exemplo da estrutura de metadata:

```python
{
  'id': 13646493,
  'document_id': '17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP',
  'name': 'What is a large language model (LLM)_ _ Cloudflare.pdf',
  'type': 'application/pdf',
  'path': '/langchain/What is a large language model (LLM)_ _ Cloudflare.pdf',
  'url': 'https://drive.google.com/file/d/17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP/view',
  'size': 337089,
  'created_time': '',
  'modified_time': '',
  'indexed_on': '2024-04-04T03:36:28.886170Z',
  'integration': {'id': 347, 'integration_type': 'google_drive'}
}

Exemplos Avançados

Construindo um Sistema de Perguntas e Respostas RAG

Este exemplo cria um sistema de perguntas e respostas que recupera informações do Rememberizer e usa o GPT-3.5 para formular respostas:

import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

Configurar chaves da API

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"

Inicialize o recuperador e o modelo de linguagem

retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)

Crie uma cadeia de QA de recuperação

qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # Método mais simples - apenas coloque todos os documentos no prompt retriever=retriever, return_source_documents=True )

Faça uma pergunta

response = qa_chain.invoke({"query": "O que é RAG no contexto da IA?"})

Imprimir a resposta

print(f"Resposta: {response['result']}") print("\nFontes:") for idx, doc in enumerate(response['source_documents']): print(f"{idx+1}. {doc.metadata['name']}")


### Construindo um Agente Conversacional com Memória

Este exemplo cria um agente conversacional que pode manter o histórico da conversa:

```python
import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI

Configurar chaves da API

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"

Inicializar componentes

retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo") memory = ConversationBufferMemory( memory_key="chat_history", return_messages=True )

Crie a cadeia conversacional

conversation = ConversationalRetrievalChain.from_llm( llm=llm, retriever=retriever, memory=memory )

Exemplo de conversa

questions = [ "O que é RAG?", "Como os grandes modelos de linguagem o utilizam?", "Quais são as limitações dessa abordagem?", ]

for question in questions: response = conversation.invoke({"question": question}) print(f"Pergunta: {question}") print(f"Resposta: {response['answer']}\n")


## Melhores Práticas

### Otimizando o Desempenho de Recuperação

1. **Seja específico com as consultas**: Consultas mais específicas geralmente produzem melhores resultados
2. **Ajuste `top_k_results`**: Comece com 3-5 resultados e ajuste com base nas necessidades da aplicação
3. **Use janelas de contexto**: O recuperador inclui automaticamente contexto em torno dos trechos correspondentes

### Considerações de Segurança

1. **Proteja sua chave de API**: Armazene-a com segurança usando variáveis de ambiente ou ferramentas de gerenciamento de segredos
2. **Crie chaves dedicadas**: Crie chaves de API separadas para diferentes aplicações
3. **Gire as chaves regularmente**: Gere novas chaves periodicamente e descontinue as antigas

### Padrões de Integração

1. **Processamento pré-retrieval**: Considere pré-processar consultas de usuários para melhorar a relevância da busca
2. **Filtragem pós-retrieval**: Filtrar ou classificar documentos recuperados antes de passar para o LLM
3. **Busca híbrida**: Combine Rememberizer com outros recuperadores usando `EnsembleRetriever`

```python
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import RememberizerRetriever, WebResearchRetriever

Criar recuperadores

rememberizer_retriever = RememberizerRetriever(top_k_results=3) web_retriever = WebResearchRetriever(...) # Configurar outro recuperador

Crie um conjunto com pontuação ponderada

ensemble_retriever = EnsembleRetriever( retrievers=[rememberizer_retriever, web_retriever], weights=[0.7, 0.3] # Os resultados do Rememberizer têm maior peso )


## Solução de Problemas

### Problemas Comuns

1. **Erros de autenticação**: Verifique se sua chave de API está correta e devidamente configurada
2. **Nenhum resultado retornado**: Certifique-se de que seu Conhecimento Comum contém informações relevantes
3. **Limitação de taxa**: Esteja atento aos limites de taxa da API para aplicações de alto volume

### Dicas de Depuração

- Defina o modo de depuração do LangChain para ver chamadas de API detalhadas:
  ```python
  import langchain
  langchain.debug = True

  • Examine os resultados de busca brutos antes de passar para o LLM para identificar problemas de recuperação

Recursos Relacionados

PreviousCriando um Rememberizer GPTNextArmazenamentos Vetoriais

Last updated