# LangChain-integration

## 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.

{% embed url="<https://python.langchain.com/docs/integrations/retrievers/rememberizer/>" %}

### 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](https://docs.rememberizer.ai/developer/registering-and-using-api-keys).

#### Installation

Installer de nødvendige pakker:

```bash
pip install langchain langchain_community
```

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

```bash
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`

   ```python
   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

   ```python
   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:

```python
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:

```python
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](https://python.langchain.com/docs/concepts/#retrievers)
* LangChain [Retriever how-to guider](https://python.langchain.com/docs/how_to/#retrievers)
* Rememberizer [API Dokumentation](https://docs.rememberizer.ai/developer/api-docs/)
* [Vektorbutikker](https://docs.rememberizer.ai/developer/vector-stores) i Rememberizer
* [Oprettelse af en Rememberizer GPT](/da/udviklerressourcer/integration-options/creating-a-rememberizer-gpt.md) - En alternativ tilgang til AI-integration


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rememberizer.ai/da/udviklerressourcer/integration-options/langchain-integration.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.