LangChain-integration

Lær hvordan du integrerer Rememberizer som en LangChain retriever for at give din LangChain-applikation adgang til kraftfuld søgning i vektordatabase.

LangChain Integration

Rememberizer integreres med LangChain gennem RememberizerRetriever klassen, hvilket gør det muligt for dig nemt at inkorporere Rememberizers semantiske søgefunktioner i dine LangChain-drevne applikationer. Denne vejledning forklarer, hvordan du opsætter og bruger denne integration til at bygge avancerede LLM-applikationer med adgang til din vidensbase.

Introduktion

LangChain er et populært framework til at bygge applikationer med store sprogmodeller (LLMs). Ved at integrere Rememberizer med LangChain kan du:

• Bruge din Rememberizer vidensbase i RAG (Retrieval Augmented Generation) applikationer

• Oprette chatbots med adgang til dine dokumenter og data

• Bygge spørgsmål-svar systemer, der udnytter din viden

• Udvikle agenter, der kan søge og ræsonnere over dine oplysninger

Integrationen er tilgængelig i langchain_community.retrievers modulet.

https://python.langchain.com/docs/integrations/retrievers/rememberizer/python.langchain.com

Kom godt i gang

Forudsætninger

Før du begynder, skal du have:

1. En Rememberizer-konto med Common Knowledge oprettet

2. En API-nøgle til at få adgang til din Common Knowledge

3. Et Python-miljø med LangChain installeret

For detaljerede instruktioner om oprettelse af Common Knowledge og generering af en API-nøgle, se Registrering og brug af API-nøgler.

Installation

Installer de nødvendige pakker:

pip install langchain langchain_community

Hvis du planlægger at bruge OpenAI-modeller (som vist i eksemplerne nedenfor):

pip install langchain_openai

Godkendelsesopsætning

Der er to måder at godkende RememberizerRetriever på:

1. Miljøvariabel: Sæt miljøvariablen REMEMBERIZER_API_KEY

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

2. Direkte parameter: Giv API-nøglen direkte, når du initialiserer retrieveren

   retriever = RememberizerRetriever(rememberizer_api_key="rem_ck_your_api_key")

Konfigurationsmuligheder

RememberizerRetriever klassen accepterer disse parametre:

Parameter	Type	Standard	Beskrivelse
top_k_results	int	10	Antal dokumenter der skal returneres fra søgningen
rememberizer_api_key	str	None	API-nøgle til autentificering (valgfri hvis sat som miljøvariabel)

Bag kulisserne foretager retrieveren API-opkald til Rememberizers søge-endpoint med yderligere konfigurerbare parametre:

Avanceret Parameter	Beskrivelse
prev_chunks	Antal chunks før den matchede chunk der skal inkluderes (standard: 2)
next_chunks	Antal chunks efter den matchede chunk der skal inkluderes (standard: 2)
return_full_content	Om der skal returneres fuldt dokumentindhold (standard: true)

Grundlæggende Brug

Her er et simpelt eksempel på at hente dokumenter fra Rememberizer ved hjælp af LangChain:

import os
from langchain_community.retrievers import RememberizerRetriever

Indstil din API-nøgle

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

Initialiser retrieveren

retriever = RememberizerRetriever(top_k_results=5)

Hent relevante dokumenter til en forespørgsel

docs = retriever.get_relevant_documents(query="Hvordan fungerer vektorembeddings?")

Vis det første dokument

if docs: print(f"Dokument: {docs[0].metadata['name']}") print(f"Indhold: {docs[0].page_content[:200]}...")

### Forståelse af Dokumentstruktur

Hvert dokument, der returneres af retrieveren, har:

- `page_content`: Tekstindholdet af det matchede dokumentchunk
- `metadata`: Yderligere information om dokumentet

Eksempel på metadata struktur:

```python
{
  'id': 13646493,
  'document_id': '17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP',
  'name': 'Hvad er en stor sprogmodel (LLM)_ _ Cloudflare.pdf',
  'type': 'application/pdf',
  'path': '/langchain/Hvad er en stor sprogmodel (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'}
}

Avancerede Eksempler

Bygning af et RAG Spørgsmål-Svar System

Dette eksempel opretter et spørgsmål-svar system, der henter information fra Rememberizer og bruger GPT-3.5 til at formulere svar:

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

Opsæt API-nøgler

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

Initialiser retrieveren og sprogmodellen

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

Opret en retrieval QA kæde

qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # Den simpleste metode - bare fyld alle dokumenter ind i prompten retriever=retriever, return_source_documents=True )

Stil et spørgsmål

response = qa_chain.invoke({"query": "Hvad er RAG i konteksten af AI?"})

Print svaret

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

### Bygning af en samtaleagent med hukommelse

Dette eksempel opretter en samtaleagent, der kan opretholde samtalehistorik:

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

Opsæt API-nøgler

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

Initialiser komponenter

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

Opret den samtale kæde

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

Eksempel på samtale

questions = [ "Hvad er RAG?", "Hvordan bruger store sprogmodeller det?", "Hvad er begrænsningerne ved denne tilgang?", ]

for question in questions: response = conversation.invoke({"question": question}) print(f"Spørgsmål: {question}") print(f"Svar: {response['answer']}\n")

## Bedste Praksis

### Optimering af hentningsydelse

1. **Vær specifik med forespørgsler**: Mere specifikke forespørgsler giver normalt bedre resultater
2. **Justér `top_k_results`**: Start med 3-5 resultater og justér baseret på applikationens behov
3. **Brug kontekstvinduer**: Hentningsværktøjet inkluderer automatisk kontekst omkring matchede bidder

### Sikkerhedsovervejelser

1. **Beskyt din API-nøgle**: Opbevar den sikkert ved hjælp af miljøvariabler eller værktøjer til hemmelighedshåndtering
2. **Opret dedikerede nøgler**: Opret separate API-nøgler til forskellige applikationer
3. **Rotér nøgler regelmæssigt**: Generer periodisk nye nøgler og udfas gamle

### Integrationsmønstre

1. **Forbehandlingsbehandling**: Overvej at forbehandle brugerforespørgsler for at forbedre søgerelevansen
2. **Efterbehandlingsfiltrering**: Filtrer eller ranger hentede dokumenter, før de sendes til LLM
3. **Hybrid søgning**: Kombiner Rememberizer med andre retrievere ved hjælp af `EnsembleRetriever`

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

Opret retrievere

rememberizer_retriever = RememberizerRetriever(top_k_results=3) web_retriever = WebResearchRetriever(...) # Konfigurer en anden retriever

Opret et ensemble med vægtet score

ensemble_retriever = EnsembleRetriever( retrievers=[rememberizer_retriever, web_retriever], weights=[0.7, 0.3] # Rememberizer-resultater har højere vægt )

## Fejlfinding

### Almindelige problemer

1. **Godkendelsesfejl**: Bekræft, at din API-nøgle er korrekt og korrekt konfigureret
2. **Ingen resultater returneret**: Sørg for, at din Common Knowledge indeholder relevante oplysninger
3. **Ratebegrænsning**: Vær opmærksom på API-ratebegrænsninger for applikationer med høj volumen

### Fejlfindingstips

- Sæt LangChain debug-tilstand for at se detaljerede API-opkald:
  ```python
  import langchain
  langchain.debug = True

• Undersøg rå søgeresultater, før de sendes til LLM for at identificere hentningsproblemer

Relaterede ressourcer

• LangChain Retriever konceptuel guide

• LangChain Retriever how-to guider

• Rememberizer API Dokumentation

• Vektorbutikker i Rememberizer

• Oprettelse af en Rememberizer GPT - En alternativ tilgang til AI-integration