# Tích hợp LangChain

## Tích hợp LangChain

Rememberizer tích hợp với LangChain thông qua lớp `RememberizerRetriever`, cho phép bạn dễ dàng kết hợp khả năng tìm kiếm ngữ nghĩa của Rememberizer vào các ứng dụng được hỗ trợ bởi LangChain. Hướng dẫn này giải thích cách thiết lập và sử dụng tích hợp này để xây dựng các ứng dụng LLM tiên tiến với quyền truy cập vào cơ sở tri thức của bạn.

### Giới thiệu

LangChain là một framework phổ biến để xây dựng các ứng dụng với các mô hình ngôn ngữ lớn (LLMs). Bằng cách tích hợp Rememberizer với LangChain, bạn có thể:

* Sử dụng cơ sở kiến thức Rememberizer của bạn trong các ứng dụng RAG (Tạo ra Tăng cường Tìm kiếm)
* Tạo ra các chatbot có quyền truy cập vào tài liệu và dữ liệu của bạn
* Xây dựng các hệ thống trả lời câu hỏi tận dụng kiến thức của bạn
* Phát triển các tác nhân có thể tìm kiếm và suy luận trên thông tin của bạn

Sự tích hợp có sẵn trong mô-đun `langchain_community.retrievers`.

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

### Bắt đầu

#### Điều kiện tiên quyết

Trước khi bắt đầu, bạn cần:

1. Một tài khoản Rememberizer với Common Knowledge đã được tạo
2. Một khóa API để truy cập vào Common Knowledge của bạn
3. Môi trường Python với LangChain đã được cài đặt

Để biết hướng dẫn chi tiết về cách tạo Common Knowledge và tạo khóa API, xem [Đăng ký và Sử dụng Khóa API](https://docs.rememberizer.ai/developer/registering-and-using-api-keys).

#### Cài đặt

Cài đặt các gói cần thiết:

```bash
pip install langchain langchain_community
```

Nếu bạn dự định sử dụng các mô hình OpenAI (như được hiển thị trong các ví dụ bên dưới):

```bash
pip install langchain_openai
```

#### Thiết lập xác thực

Có hai cách để xác thực `RememberizerRetriever`:

1. **Biến Môi Trường**: Đặt biến môi trường `REMEMBERIZER_API_KEY`

   ```python
   import os
   os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"
   ```
2. **Tham Số Trực Tiếp**: Truyền trực tiếp khóa API khi khởi tạo bộ thu

   ```python
   retriever = RememberizerRetriever(rememberizer_api_key="rem_ck_your_api_key")
   ```

### Tùy Chọn Cấu Hình

Lớp `RememberizerRetriever` chấp nhận các tham số sau:

| Tham số                | Loại | Mặc định | Mô tả                                                           |
| ---------------------- | ---- | -------- | --------------------------------------------------------------- |
| `top_k_results`        | int  | 10       | Số lượng tài liệu để trả về từ tìm kiếm                         |
| `rememberizer_api_key` | str  | None     | Khóa API để xác thực (tùy chọn nếu được đặt là biến môi trường) |

Trong bối cảnh, bộ truy xuất thực hiện các cuộc gọi API đến điểm cuối tìm kiếm của Rememberizer với các tham số cấu hình bổ sung:

| Tham số Nâng Cao      | Mô tả                                                         |
| --------------------- | ------------------------------------------------------------- |
| `prev_chunks`         | Số lượng khối trước khối khớp để bao gồm (mặc định: 2)        |
| `next_chunks`         | Số lượng khối sau khối khớp để bao gồm (mặc định: 2)          |
| `return_full_content` | Có trả về nội dung tài liệu đầy đủ hay không (mặc định: true) |

### Cách Sử Dụng Cơ Bản

Dưới đây là một ví dụ đơn giản về việc truy xuất tài liệu từ Rememberizer bằng cách sử dụng LangChain:

```python
import os
from langchain_community.retrievers import RememberizerRetriever
```

## Đặt khóa API của bạn

os.environ\["REMEMBERIZER\_API\_KEY"] = "rem\_ck\_your\_api\_key"

## Khởi tạo bộ truy xuất

retriever = RememberizerRetriever(top\_k\_results=5)

## Lấy tài liệu liên quan cho một truy vấn

docs = retriever.get\_relevant\_documents(query="Vector embeddings hoạt động như thế nào?")

## Hiển thị tài liệu đầu tiên

if docs: print(f"Tài liệu: {docs\[0].metadata\['name']}") print(f"Nội dung: {docs\[0].page\_content\[:200]}...")

````

### Hiểu Cấu Trúc Tài Liệu

Mỗi tài liệu được trả về bởi bộ thu hồi có:

- `page_content`: Nội dung văn bản của đoạn tài liệu đã khớp
- `metadata`: Thông tin bổ sung về tài liệu

Ví dụ về cấu trúc 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'}
}
````

### Ví dụ Nâng Cao

#### Xây dựng Hệ thống Hỏi-Đáp RAG

Ví dụ này tạo ra một hệ thống hỏi-đáp mà truy xuất thông tin từ Rememberizer và sử dụng GPT-3.5 để hình thành câu trả lời:

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

## Thiết lập khóa API

os.environ\["REMEMBERIZER\_API\_KEY"] = "rem\_ck\_your\_api\_key" os.environ\["OPENAI\_API\_KEY"] = "your\_openai\_api\_key"

## Khởi tạo bộ truy xuất và mô hình ngôn ngữ

retriever = RememberizerRetriever(top\_k\_results=5) llm = ChatOpenAI(model\_name="gpt-3.5-turbo", temperature=0)

## Tạo một chuỗi QA truy xuất

qa\_chain = RetrievalQA.from\_chain\_type( llm=llm, chain\_type="stuff", # Phương pháp đơn giản nhất - chỉ cần nhét tất cả tài liệu vào lời nhắc retriever=retriever, return\_source\_documents=True )

## Đặt câu hỏi

response = qa\_chain.invoke({"query": "RAG là gì trong bối cảnh AI?"})

## In ra câu trả lời

print(f"Câu trả lời: {response\['result']}") print("\nNguồn:") for idx, doc in enumerate(response\['source\_documents']): print(f"{idx+1}. {doc.metadata\['name']}")

````

### Xây Dựng Một Đại Lý Đàm Thoại Có Bộ Nhớ

Ví dụ này tạo ra một đại lý đàm thoại có thể duy trì lịch sử cuộc trò chuyện:

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

## Thiết lập khóa API

os.environ\["REMEMBERIZER\_API\_KEY"] = "rem\_ck\_your\_api\_key" os.environ\["OPENAI\_API\_KEY"] = "your\_openai\_api\_key"

## Khởi tạo các thành phần

retriever = RememberizerRetriever(top\_k\_results=5) llm = ChatOpenAI(model\_name="gpt-3.5-turbo") memory = ConversationBufferMemory( memory\_key="chat\_history", return\_messages=True )

## Tạo chuỗi hội thoại

conversation = ConversationalRetrievalChain.from\_llm( llm=llm, retriever=retriever, memory=memory )

## Ví dụ cuộc trò chuyện

questions = \[ "RAG là gì?", "Các mô hình ngôn ngữ lớn sử dụng nó như thế nào?", "Những hạn chế của phương pháp này là gì?", ]

for question in questions: response = conversation.invoke({"question": question}) print(f"Câu hỏi: {question}") print(f"Câu trả lời: {response\['answer']}\n")

````

## Thực Hành Tốt Nhất

### Tối ưu hóa hiệu suất truy xuất

1. **Cụ thể với các truy vấn**: Các truy vấn cụ thể hơn thường mang lại kết quả tốt hơn
2. **Điều chỉnh `top_k_results`**: Bắt đầu với 3-5 kết quả và điều chỉnh dựa trên nhu cầu ứng dụng
3. **Sử dụng cửa sổ ngữ cảnh**: Bộ truy xuất tự động bao gồm ngữ cảnh xung quanh các đoạn khớp

### Các cân nhắc về bảo mật

1. **Bảo vệ khóa API của bạn**: Lưu trữ nó một cách an toàn bằng cách sử dụng biến môi trường hoặc công cụ quản lý bí mật
2. **Tạo khóa riêng biệt**: Tạo các khóa API riêng cho các ứng dụng khác nhau
3. **Thay đổi khóa thường xuyên**: Định kỳ tạo khóa mới và loại bỏ các khóa cũ

### Mô hình tích hợp

1. **Xử lý trước khi truy xuất**: Xem xét việc tiền xử lý các truy vấn của người dùng để cải thiện độ liên quan của tìm kiếm
2. **Lọc sau khi truy xuất**: Lọc hoặc xếp hạng các tài liệu đã truy xuất trước khi chuyển cho LLM
3. **Tìm kiếm kết hợp**: Kết hợp Rememberizer với các bộ truy xuất khác bằng cách sử dụng `EnsembleRetriever`

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

## Tạo bộ thu thập

rememberizer\_retriever = RememberizerRetriever(top\_k\_results=3) web\_retriever = WebResearchRetriever(...) # Cấu hình bộ thu thập khác

## Tạo một bộ với điểm số có trọng số

ensemble\_retriever = EnsembleRetriever( retrievers=\[rememberizer\_retriever, web\_retriever], weights=\[0.7, 0.3] # Kết quả từ Rememberizer có trọng số cao hơn )

````

## Khắc phục sự cố

### Vấn đề Thường Gặp

1. **Lỗi xác thực**: Xác minh rằng khóa API của bạn đúng và được cấu hình chính xác
2. **Không có kết quả trả về**: Đảm bảo rằng Kiến thức Chung của bạn chứa thông tin liên quan
3. **Giới hạn tần suất**: Hãy chú ý đến giới hạn tần suất API cho các ứng dụng có khối lượng lớn

### Mẹo Gỡ Rối

- Đặt chế độ gỡ rối của LangChain để xem các cuộc gọi API chi tiết:
  ```python
  import langchain
  langchain.debug = True
````

* Kiểm tra kết quả tìm kiếm thô trước khi truyền cho LLM để xác định các vấn đề truy xuất

### Tài nguyên liên quan

* Hướng dẫn khái niệm \[Retriever] của LangChain (<https://python.langchain.com/docs/concepts/#retrievers>)
* Hướng dẫn cách thực hiện \[Retriever] của LangChain (<https://python.langchain.com/docs/how\\_to/#retrievers>)
* Tài liệu \[API] của Rememberizer (<https://docs.rememberizer.ai/developer/api-docs/>)
* \[Cửa hàng Vector] (<https://docs.rememberizer.ai/developer/vector-stores>) trong Rememberizer
* \[Tạo một Rememberizer GPT] (creating-a-rememberizer-gpt.md) - Một phương pháp thay thế cho việc tích hợp AI