LangChain tutorial

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

langchainpythonrag