Budowanie agentów LLM dla RAG od podstaw i poza: Kompleksowy przewodnik

LLM jak GPT-3, GPT-4 i ich otwarte odpowiedniki często mają trudności z pobieraniem informacji na bieżący temat i czasem generują halucynacje lub nieprawidłowe informacje.

Retrieval-Augmented Generation (RAG) to technika, która łączy moc LLM z zewnętrznym pobieraniem wiedzy. RAG pozwala nam oprzeć odpowiedzi LLM na faktach, bieżących informacjach, znacznie poprawiając dokładność i niezawodność generowanego przez AI treści.

W tym poście blogowym będziemy badać, jak zbudować agenci LLM dla RAG od podstaw, zagłębiając się w architekturę, szczegóły implementacji i zaawansowane techniki. Będziemy pokrywać wszystko, od podstaw RAG do tworzenia zaawansowanych agentów zdolnych do złożonego rozumowania i wykonywania zadań.

Przed rozpoczęciem budowy naszego agenta LLM, rozważmy, co to jest RAG i dlaczego jest ważne.

RAG, czyli Retrieval-Augmented Generation, to hybrydowy podejście, które łączy pobieranie informacji z generowaniem tekstu. W systemie RAG:

• Zapytanie służy do pobrania istotnych dokumentów z bazy wiedzy.
• Te dokumenty są następnie wprowadzane do modelu językowego wraz z oryginalnym zapytaniem.
• Model generuje odpowiedź na podstawie zapytania i pobranych informacji.

RAG

To podejście ma kilka zalet:

• Poprawiona dokładność: Poprzez opracowanie odpowiedzi w oparciu o pobrane informacje, RAG redukuje halucynacje i poprawia dokładność faktów.
• Bieżące informacje: Baza wiedzy może być regularnie aktualizowana, umożliwiając systemowi dostęp do bieżących informacji.
• Przejrzystość: System może podać źródła swoich informacji, zwiększając zaufanie i umożliwiając weryfikację faktów.

Zrozumienie agentów LLM

LLM Powered Agents

Gdy napotkasz problem bez prostego rozwiązania, często musisz wykonać kilka kroków, starannie przemyśleć i zapamiętać, co już spróbowałeś. Agenci LLM są zaprojektowani specjalnie dla tego rodzaju sytuacji w aplikacjach modeli językowych. Łączą dogłębną analizę danych, strategiczne planowanie, pobieranie danych i możliwość uczenia się z przeszłych działań, aby rozwiązać złożone problemy.

Czym są agenci LLM?

Agenci LLM to zaawansowane systemy AI zaprojektowane do tworzenia złożonego tekstu, który wymaga sekwencyjnego rozumowania. Mogą myśleć naprzód, pamiętać poprzednie rozmowy i używać różnych narzędzi, aby dostosować swoje odpowiedzi do sytuacji i stylu potrzebnego.

Rozważmy pytanie z dziedziny prawa, takie jak: “Jakie są potencjalne skutki prawne naruszenia określonego typu umowy w Kalifornii?” Podstawowy LLM z systemem RAG może pobrać niezbędne informacje z baz prawnych.

Dla bardziej szczegółowego scenariusza: “W świetle nowych przepisów o ochronie danych, jakie są powszechne wyzwania prawne, z którymi spotykają się firmy, i jak sądy rozpatrują te sprawy?” To pytanie sięga głębiej niż tylko wyszukiwanie faktów. Chodzi o zrozumienie nowych przepisów, ich wpływu na różne firmy i odpowiedzi sądów. Agent LLM rozbiłby to zadanie na podzadania, takie jak pobranie najnowszych przepisów, analiza historycznych przypadków, podsumowanie dokumentów prawnych i prognozowanie trendów na podstawie wzorców.

Składniki agentów LLM

Agenci LLM składają się zwykle z czterech składników:

1. Agent/Mózg: Podstawowy model językowy, który przetwarza i rozumie język.
2. Planowanie: Możliwość rozumowania, rozbić zadań i tworzenia konkretnych planów.
3. Pamięć: Utrzymuje rekordy poprzednich interakcji i uczy się z nich.
4. Użycie narzędzi: Integruje różne zasoby, aby wykonać zadania.

Agent/Mózg

W centrum agenta LLM znajduje się model językowy, który przetwarza i rozumie język na podstawie ogromnych ilości danych, na których został wyszkolony. Zaczynasz od podania mu konkretnego promtu, prowadząc agenta, jak odpowiedzieć, jakie narzędzia użyć i jakie cele osiągnąć. Możesz dostosować agenta do określonej osobowości, odpowiedniej dla konkretnych zadań lub interakcji, poprawiając jego wydajność.

Pamięć

Składnik pamięci pomaga agentom LLM radzić sobie z złożonymi zadaniami, utrzymując rekord poprzednich działań. Istnieją dwa główne typy pamięci:

• Pamięć krótkotrwała: Działa jak notatnik, śledząc bieżące dyskusje.
• Pamięć długotrwała: Funkcjonuje jak dziennik, przechowując informacje z poprzednich interakcji, aby nauczyć się wzorców i podejmować lepsze decyzje.

Łącząc te typy pamięci, agent może oferować bardziej dopasowane odpowiedzi i pamiętać preferencje użytkownika w czasie, tworząc bardziej połączoną i istotną interakcję.

Planowanie

Planowanie umożliwia agentom LLM rozumowanie, rozbić zadań na mniejsze części i dostosowywać plany, gdy zadania ewoluują. Planowanie obejmuje dwa główne etapy:

• Formułowanie planu: Rozbić zadania na mniejsze podzadania.
• Odwzorowanie planu: Przegląd i ocena skuteczności planu, włączając informacje zwrotne, aby udoskonalić strategie.

Metody takie jak Chain of Thought (CoT) i Tree of Thought (ToT) pomagają w tym procesie dekompozycji, pozwalając agentom na eksplorację różnych ścieżek, aby rozwiązać problem.

Aby zagłębić się w świat agentów AI, w tym ich bieżące możliwości i potencjał, rozważ przeczytanie “Auto-GPT & GPT-Engineer: An In-Depth Guide to Today’s Leading AI Agents”

Konfigurowanie środowiska

Aby zbudować naszego agenta RAG, musimy skonfigurować nasze środowisko programistyczne. Będziemy używać Pythona i kilku kluczowych bibliotek:

• LangChain: Do orchestracji naszego LLM i składników pobierania.
• Chroma: Jako nasz magazyn wektorowy dla osadzania dokumentów.
• Modele GPT OpenAI: Jako nasz podstawowy LLM (możesz go zastąpić modelem open-source, jeśli wolisz).
• FastAPI: Do tworzenia prostego API do interakcji z naszym agentem.

Zacznijmy od skonfigurowania naszego środowiska:

# Utwórz nowe środowisko wirtualne
python -m venv rag_agent_env
source rag_agent_env/bin/activate # Na Windows, użyj `rag_agent_env\Scripts\activate`

# Zainstaluj wymagane pakiety
pip install langchain chromadb openai fastapi uvicorn

Teraz utwórz nowy plik Python o nazwie rag_agent.py i zaimportuj niezbędne biblioteki:

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
import os

# Ustaw swój klucz API OpenAI
os.environ["OPENAI_API_KEY"] = "twój-klucz-api-tutaj"

Budowanie prostego systemu RAG

Teraz, gdy mamy skonfigurowane środowisko, zbudujmy podstawowy system RAG. Zacznijmy od utworzenia bazy wiedzy z zestawu dokumentów, a następnie użyjemy jej do odpowiedzi na zapytania.

Krok 1: Przygotuj dokumenty

Najpierw musimy załadować i przygotować nasze dokumenty. Załóżmy, że mamy plik tekstowy o nazwie knowledge_base.txt z pewnymi informacjami o AI i uczeniu maszynowym.

# Załaduj dokument
loader = TextLoader("knowledge_base.txt")
documents = loader.load()

# Podziel dokumenty na fragmenty
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# Utwórz osadzania
embeddings = OpenAIEmbeddings()

# Utwórz magazyn wektorowy
vectorstore = Chroma.from_documents(texts, embeddings)

Krok 2: Utwórz łańcuch QA oparty na pobieraniu

Teraz, gdy mamy magazyn wektorowy, możemy utworzyć łańcuch QA oparty na pobieraniu:

# Utwórz łańcuch QA oparty na pobieraniu
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())

Krok 3: Zapytaj system

Możemy teraz zapytać nasz system RAG:

query = "Jakie są główne zastosowania uczenia maszynowego?"
result = qa.run(query)
print(result)

Krok 4: Tworzenie agenta LLM

Podczas gdy nasz prosty system RAG jest użyteczny, jest dość ograniczony. Poprawmy go, tworząc agenta LLM, który może wykonywać bardziej złożone zadania i rozumować o informacjach, które pobiera.

Agent LLM to system AI, który może używać narzędzi i podejmować decyzje o działaniach. Utworzymy agenta, który może nie tylko odpowiadać na pytania, ale także wykonywać wyszukiwania w sieci i podstawowe obliczenia.

Najpierw zdefiniujmy kilka narzędzi dla naszego agenta:

from langchain.agents import Tool
from langchain.tools import DuckDuckGoSearchRun
from langchain.tools import BaseTool
from langchain.agents import initialize_agent
from langchain.agents import AgentType

# Zdefiniuj narzędzie do obliczeń
class CalculatorTool(BaseTool):
name = “Calculator”
description = “Użyteczne, gdy potrzebujesz odpowiedzi na pytania matematyczne”

def _run(self, query: str)