LLM & Agenti

LangChain tutorial

12 min čtení
LangChainPythonRAG

LangChain je výkonný framework pro vývoj aplikací s velkými jazykovými modely (LLM). V tomto tutoriálu si ukážeme, jak vytvářet inteligentní AI agenty a propojovat je s externími nástroji a databázemi.

Úvod do LangChain: Stavba AI aplikací

LangChain je výkonný Python framework navržený pro vývoj aplikací využívajících Large Language Models (LLM). Tento tutorial vás provede základními koncepty a praktickými příklady, které vám pomohou rychle začít s budováním vlastních AI řešení.

Instalace a základní nastavení

Pro začátek práce s LangChain nainstalujeme potřebné závislosti:

pip install langchain langchain-openai python-dotenv

Vytvoříme soubor .env pro uložení API klíčů:

OPENAI_API_KEY=your_openai_api_key_here

Základní konfigurace

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage

load_dotenv()

# Inicializace LLM
llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.7,
    api_key=os.getenv("OPENAI_API_KEY")
)

Práce s Prompt Templates

Prompt Templates umožňují dynamické vytváření promptů s parametry. To je klíčové pro škálovatelné aplikace:

from langchain.prompts import PromptTemplate, ChatPromptTemplate

# Jednoduchý template
simple_template = PromptTemplate(
    input_variables=["product"],
    template="Napiš marketingový popis pro {product}"
)

# Chat template s více rolemi
chat_template = ChatPromptTemplate.from_messages([
    ("system", "Jsi expert na {domain}"),
    ("human", "Vysvětli mi {concept} jednoduchými slovy")
])

# Použití
prompt = chat_template.format_messages(
    domain="machine learning",
    concept="gradient descent"
)

response = llm.invoke(prompt)

Chains: Propojení komponent

Chains představují srdce LangChain architektury. Umožňují propojit různé komponenty do komplexních workflow:

from langchain.chains import LLMChain
from langchain.chains import SimpleSequentialChain

# Základní chain
llm_chain = LLMChain(
    llm=llm,
    prompt=simple_template
)

result = llm_chain.run("chytrý telefon")
print(result)

# Sekvenční chain - výstup první části je vstup druhé
template1 = PromptTemplate(
    input_variables=["concept"],
    template="Vysvětli koncept {concept} v jedné větě"
)

template2 = PromptTemplate(
    input_variables=["explanation"],
    template="Vytvoř praktický příklad pro: {explanation}"
)

chain1 = LLMChain(llm=llm, prompt=template1)
chain2 = LLMChain(llm=llm, prompt=template2)

overall_chain = SimpleSequentialChain(
    chains=[chain1, chain2],
    verbose=True
)

result = overall_chain.run("blockchain")

Memory: Udržení kontextu konverzace

Pro chatboty a interaktivní aplikace je klíčové udržení kontextu předchozích zpráv:

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Inicializace memory
memory = ConversationBufferMemory()

# Konverzační chain s pamětí
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# Dialog
response1 = conversation.predict(input="Jak se jmenuji?")
print(response1)

response2 = conversation.predict(input="Jmenuji se Pavel")
print(response2)

response3 = conversation.predict(input="Jaké je mé jméno?")
print(response3)  # LLM si vzpomene na jméno Pavel

RAG: Retrieval-Augmented Generation

RAG umožňuje LLM pracovat s externími daty. Ukážeme si implementaci systému pro dotazování nad dokumenty:

Příprava dat a embeddings

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS

# Načtení dokumentu
loader = TextLoader("document.txt", encoding="utf-8")
documents = loader.load()

# Rozdělení na chunky
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = text_splitter.split_documents(documents)

# Vytvoření embeddings
embeddings = OpenAIEmbeddings()

# Vytvoření vector store
vectorstore = FAISS.from_documents(chunks, embeddings)

QA systém s RAG

from langchain.chains import RetrievalQA

# QA chain s retrieval
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# Dotaz
query = "Jaké jsou hlavní výhody mikroservic?"
result = qa_chain({"query": query})

print("Odpověď:", result["result"])
print("\nZdrojové dokumenty:")
for doc in result["source_documents"]:
    print(f"- {doc.page_content[:100]}...")

Agents: Autonomní rozhodování

Agents umí dynamicky rozhodovat, které nástroje použít na základě uživatelského vstupu:

from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
import requests

def get_weather(city):
    """Jednoduchá funkce pro získání počasí"""
    # Zde by byla integrace s weather API
    return f"V městě {city} je dnes slunečno, 22°C"

def calculate(expression):
    """Bezpečná kalkulačka"""
    try:
        result = eval(expression)
        return f"Výsledek: {result}"
    except:
        return "Chyba při výpočtu"

# Definice nástrojů
tools = [
    Tool(
        name="Weather",
        func=get_weather,
        description="Získá informace o počasí pro zadané město"
    ),
    Tool(
        name="Calculator",
        func=calculate,
        description="Provede matematický výpočet"
    )
]

# Inicializace agenta
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Použití agenta
response = agent.run("Jaké je počasí v Praze a kolik je 15 * 7?")
print(response)

Praktické tipy pro produkční použití

Error handling a retry logika

from tenacity import retry, stop_after_attempt, wait_random_exponential

@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))
def llm_with_retry(prompt):
    try:
        return llm.invoke(prompt)
    except Exception as e:
        print(f"Chyba: {e}")
        raise

Optimalizace nákladů

  • Používejte cache pro opakované dotazy
  • Optimalizujte délku promptů
  • Implementujte rate limiting
  • Monitorujte spotřebu tokenů

Shrnutí

LangChain poskytuje robustní framework pro stavbu pokročilých AI aplikací. Klíčové komponenty jako Prompt Templates, Chains, Memory a RAG umožňují vytvářet škálovatelná řešení. Pro produkční nasazení nezapomeňte na error handling, monitoring a optimalizaci nákladů. Tento tutorial vám dal základy - nyní můžete experimentovat s vlastními use cases a postupně rozšiřovat funkčnost vašich aplikací.

CORE SYSTEMS tým

Enterprise architekti a AI inženýři.