Конспект 11: LangChain и AI Фреймворки

❌ Без LangChain:
- Писать интеграции вручную (OpenAI, Anthropic, etc.)
- Управлять prompt templates
- Обрабатывать errors и retries
- Строить chains операций вручную
- Кучу boilerplate кода

✅ С LangChain:
- Unified API для всех LLM
- Встроенные prompt templates
- Автоматический retry logic
- Chains и Agents из коробки
- Меньше кода, больше функционала

2022: LangChain v0.0 (Harrison Chase)
2023: LangChain v0.1 (большие улучшения)
2024: LangChain v0.2 (production-ready)
2025: LangChain v1.0 (стабильный API)

Экосистема:
├─ LangChain (основной фреймворк)
├─ LangGraph (workflow orchestration)
├─ LangServe (API deployment)
├─ LangSmith (debugging & monitoring)
└─ LangHub (prompt sharing)

✅ Используй если:
- Строишь production LLM app
- Используешь multiple LLM providers
- Нужны agents и chains
- Нужен RAG
- Нужен мониторинг

❌ Не используй если:
- Простой скрипт (прямой вызов API)
- Очень низколатентные требования
- Простой prompt
- Быстрый прототип (просто используй API)

┌─────────────────────────────────────┐
│         LangChain App               │
│                                     │
│  ┌──────────────┐                  │
│  │   LLMs       │ (GPT, Claude)    │
│  └──────────────┘                  │
│                                     │
│  ┌──────────────┐                  │
│  │   Tools      │ (API, DB)        │
│  └──────────────┘                  │
│                                     │
│  ┌──────────────┐                  │
│  │   Memory     │ (Context)        │
│  └──────────────┘                  │
│                                     │
│  ┌──────────────┐                  │
│  │   Chains     │ (Workflow)       │
│  └──────────────┘                  │
│                                     │
│  ┌──────────────┐                  │
│  │   Agents     │ (Decision)       │
│  └──────────────┘                  │
└─────────────────────────────────────┘

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4-turbo",
    temperature=0.7,
    max_tokens=1000,
    api_key="sk-..."
)

# Простой вызов
response = llm.predict(text="Привет! Как дела?")
print(response)

LLM:
- Predict method (text in → text out)
- Например: GPT-2, GPT-3

ChatModel:
- Call method (messages in → message out)
- Лучше для conversation
- Имеет system, user, assistant roles

from langchain.schema import HumanMessage, SystemMessage

messages = [
    SystemMessage(content="Ты Python разработчик"),
    HumanMessage(content="Что такое decorator?")
]

response = llm(messages)
print(response.content)

from langchain.chat_models import ChatOpenAI

chat = ChatOpenAI(model="gpt-4-turbo")

from langchain.chat_models import ChatAnthropic

chat = ChatAnthropic(model="claude-3-opus")

from langchain.chat_models import ChatGooglePalm

chat = ChatGooglePalm(google_api_key="...")

from langchain.chat_models import AzureChatOpenAI

chat = AzureChatOpenAI(
    azure_endpoint="https://...",
    api_key="..."
)

Пользовательский ввод
    ↓
Prompt Template (форматирование)
    ↓
LLM (генерация)
    ↓
Output Parser (парсинг)
    ↓
Результат

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# 1. Создать prompt
prompt = PromptTemplate(
    input_variables=["topic"],
    template="Напиши 3 интересных факта о {topic}"
)

# 2. Создать chain
chain = LLMChain(llm=llm, prompt=prompt)

# 3. Выполнить
result = chain.run(topic="N8N")
print(result)

from langchain.chains import SequentialChain

# Chain 1: Generate idea
prompt1 = PromptTemplate(
    input_variables=["topic"],
    template="Придумай уникальный продукт для {topic}"
)
chain1 = LLMChain(llm=llm, prompt=prompt1, output_key="product")

# Chain 2: Generate marketing
prompt2 = PromptTemplate(
    input_variables=["product"],
    template="Напиши маркетинг слоган для {product}"
)
chain2 = LLMChain(llm=llm, prompt=prompt2, output_key="slogan")

# Объединить
sequential = SequentialChain(
    chains=[chain1, chain2],
    input_variables=["topic"],
    output_variables=["product", "slogan"]
)

result = sequential({"topic": "AI"})
print(result)

from langchain.chains.router import MultiPromptChain
from langchain.chains.router.llm_router import LLMRouterChain

# Разные prompts для разных типов вопросов
prompts = {
    "technical": "Ты expert по {domain}. Ответь на: {input}",
    "creative": "Ты creative writer. Напиши: {input}",
    "business": "Ты business consultant. Рекомендуй: {input}"
)

# Chain которая выбирает правильный prompt
router = LLMRouterChain(...)

Chain: Фиксированная последовательность (→ → →)
Agent: Гибкая, выбирает действия (↗ ↙ ↗)

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

# 1. Определить tools
tools = [
    Tool(
        name="Calculator",
        func=lambda x: eval(x),
        description="Use for math calculations"
    ),
    Tool(
        name="Search",
        func=search_function,
        description="Search the internet"
    )
]

# 2. Создать agent
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.REACT_DOCSTORE,
    verbose=True
)

# 3. Выполнить
result = agent.run("Сколько будет 2^10 + 5?")

from langchain.agents import AgentType, initialize_agent
from langchain.tools import StructuredTool
from pydantic import BaseModel, Field

# Определить tool с типами
class CalculatorInput(BaseModel):
    expression: str = Field(..., description="Math expression")

def calculate(expression: str) -> str:
    return str(eval(expression))

calculator_tool = StructuredTool.from_function(
    func=calculate,
    name="Calculator",
    description="Performs math calculations",
    args_schema=CalculatorInput
)

# Создать agent
agent = initialize_agent(
    [calculator_tool],
    llm,
    agent=AgentType.OPENAI_FUNCTIONS,
    verbose=True
)

result = agent.run("Calculate 2^10")

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()

# Добавить в историю
memory.chat_memory.add_user_message("Привет!")
memory.chat_memory.add_ai_message("Здравствуйте!")

# Получить переменные для prompt
variables = memory.load_memory_variables({})
print(variables)  # {'history': 'Human: Привет!\nAI: Здравствуйте!'}

from langchain.memory import ConversationSummaryMemory

# Автоматически суммирует старые messages
memory = ConversationSummaryMemory(llm=llm)

# Экономит токены, но теряет детали

from langchain.memory import VectorStoreBackedMemory
from langchain.vectorstores import Qdrant

# Semantic search в памяти
vectorstore = Qdrant(...)
memory = VectorStoreBackedMemory(
    vectorstore=vectorstore,
    memory_key="history"
)

# Retrieve только релевантные сообщения

from langchain.chains import ConversationChain

# Chain с памятью
conversation = ConversationChain(
    llm=llm,
    memory=ConversationBufferMemory(),
    verbose=True
)

# Первый запрос
response1 = conversation.run(input="Я живу в Москве")

# Второй запрос (помнит информацию)
response2 = conversation.run(input="Какой город я назвал?")
# Output: "Вы сказали, что живете в Москве"

from langchain.tools import Tool

def get_weather(city: str) -> str:
    """Get current weather for a city"""
    # API call to weather service
    return f"Temperature in {city}: 15°C"

weather_tool = Tool(
    name="WeatherAPI",
    func=get_weather,
    description="Get current weather for a city"
)

from langchain.tools import StructuredTool
from pydantic import BaseModel, Field

class WeatherInput(BaseModel):
    city: str = Field(..., description="City name")
    units: str = Field(default="celsius", description="C or F")

weather_tool = StructuredTool.from_function(
    func=get_weather,
    name="WeatherAPI",
    description="Get current weather",
    args_schema=WeatherInput
)

from langchain.callbacks import StdOutCallbackHandler

# Логировать все к stdout
callback = StdOutCallbackHandler()

llm.predict(text="Hi", callbacks=[callback])

# Output:
# > Entering new LLMChain of class <class 'langchain.chains.llm.LLMChain'>...
# > Prompt after formatting:
# ...

✅ LangGraph нужен для:
- Loops и conditionals
- Retry logic
- Complex decision trees
- Multi-step workflows

❌ Обычный Chain если:
- Linear workflow
- No loops
- Simple operations

from langgraph.graph import StateGraph
from typing import TypedDict, List

# 1. Определить state
class AgentState(TypedDict):
    input: str
    history: List[str]
    result: str

# 2. Создать graph
graph = StateGraph(AgentState)

# 3. Определить nodes
def research_node(state):
    # Research
    result = search(state["input"])
    state["history"].append(f"Research: {result}")
    return state

def analyze_node(state):
    # Analyze
    result = llm.predict(state["history"][-1])
    state["history"].append(f"Analysis: {result}")
    return state

def write_node(state):
    # Write
    result = llm.predict(f"Write summary: {state['history']}")
    state["result"] = result
    return state

# 4. Добавить nodes
graph.add_node("research", research_node)
graph.add_node("analyze", analyze_node)
graph.add_node("write", write_node)

# 5. Добавить edges
graph.add_edge("research", "analyze")
graph.add_edge("analyze", "write")

# 6. Compile
runnable = graph.compile()

# 7. Execute
result = runnable.invoke({
    "input": "Write about N8N",
    "history": [],
    "result": ""
})

from llama_index import GPTVectorStoreIndex, SimpleDirectoryReader

# 1. Load documents
documents = SimpleDirectoryReader('data').load_data()

# 2. Create index
index = GPTVectorStoreIndex.from_documents(documents)

# 3. Query
query_engine = index.as_query_engine()
response = query_engine.query("What is N8N?")

LlamaIndex: Лучше для RAG и document indexing
LangChain: Более universal, лучше для agents и chains

from crewai import Agent, Task, Crew

# Определить агентов
researcher = Agent(
    role="Researcher",
    goal="Find accurate information",
    llm=llm
)

writer = Agent(
    role="Writer",
    goal="Write engaging content",
    llm=llm
)

# Задачи
research_task = Task(
    description="Research about N8N",
    agent=researcher
)

write_task = Task(
    description="Write article",
    agent=writer
)

# Crew
crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])
result = crew.kickoff()

from autogen import AssistantAgent, UserProxyAgent

assistant = AssistantAgent(name="assistant")
user_proxy = UserProxyAgent(name="user")

user_proxy.initiate_chat(
    assistant,
    message="Помоги мне с Python"
)

# 1. Создать LangChain app (FastAPI)
from fastapi import FastAPI
from langchain.chains import LLMChain

app = FastAPI()

@app.post("/chain/run")
async def run_chain(input_text: str):
    result = chain.run(input_text)
    return {"result": result}

# 2. Запустить
# uvicorn app:app --reload

[Webhook trigger]
    ↓
[HTTP Request node]
    POST http://localhost:8000/chain/run
    Body: { "input_text": "..." }
    ↓
[Process response]

// N8N Custom Node для LangChain
import { IExecuteFunctions } from 'n8n-core';
import { LangChainCommon } from 'langchain';

export class LangChainNode {
    async execute(this: IExecuteFunctions) {
        const chainType = this.getNodeParameter('chainType', 0);
        const input = this.getNodeParameter('input', 0);

        // Выполнить LangChain
        const result = await this.runLangChain(chainType, input);

        return [[{ json: result }]];
    }
}

Инициализация:
☑️ LangChain установлена
☑️ API ключи настроены
☑️ Модель выбрана

Разработка:
☑️ Prompts созданы и версионированы
☑️ Chains/Agents определены
☑️ Tools интегрированы
☑️ Memory настроена

Тестирование:
☑️ Unit tests для chains
☑️ Integration tests с LLM
☑️ Edge cases проверены
☑️ Error handling есть

Production:
☑️ Callbacks для логирования
☑️ Rate limiting настроено
☑️ Monitoring включен
☑️ Документация написана