LangChain Python 2026: создаем AI агента с RAG и инструментами

LangChain Python 2026: строим AI агента с RAG за один день

LangChain v1.x с LangGraph — это сейчас стандарт для production-grade агентов на Python. Не прототип на коленке, а система с памятью, RAG и инструментами, которую можно деплоить. В этой статье разберем полный путь: от установки до рабочего агента с поиском по документам.

Ниже — пошагово: архитектура агента, RAG на своих данных, инструменты и управление памятью. Плюс разбор LangGraph для тех, кто строит мультиагентные системы.

Что такое LangChain и зачем он в 2026 году

LangChain — это Python-фреймворк для оркестрации LLM-приложений. Не просто обертка над GPT или Claude, а полноценный слой между моделью и вашей бизнес-логикой.

114 000 звезд на GitHub и регулярные коммиты — фреймворк живой и активно поддерживается командой. В январе 2026 года LangSmith Agent Builder вышел в GA, появилась возможность собирать агентов на естественном языке. Но для нетривиальных задач по-прежнему нужен код, и вот тут LangGraph становится обязательным.

По данным LangChain Survey 2026 (1 300+ разработчиков), фокус сместился с быстрых прототипов на стабильные production-системы. Большинство команд теперь используют LangGraph вместо устаревшего AgentExecutor.

Максим: «Когда мы строили первую версию RAG для NeuroScribe, взяли самый простой стек. Через две недели пришлось переписывать на LangGraph — AgentExecutor не давал нужного контроля над логикой. Если сразу строишь на LangGraph, экономишь минимум неделю итераций.»

Установка и настройка окружения

LangChain ставится через pip. Для агента с инструментами нужны два пакета:

pip install langchain langchain-openai

Если используешь OpenRouter (он дает доступ к Gemini, DeepSeek, Claude без американской карты):

pip install langchain-openai httpx

На OpenRouter есть бесплатные модели. Зайди в раздел Models, в прайсинге выставь все значения в ноль — получишь список free-моделей. Gemini Flash хорошо подходит для тестирования: быстрый, бесплатный, справляется с несложными задачами.

Для безопасной работы с ключами не вставляй их напрямую в код. Используй getpass или .env:

from getpass import getpass
api_key = getpass("Введи API ключ: ")

Минимальная версия Python — 3.10+. На более ранних версиях часть синтаксиса LangChain не работает корректно.

Архитектура: агент, инструменты и память

Агент в контексте LangChain — это LLM, который умеет принимать решения о вызове инструментов. Обычная языковая модель отвечает только из того, на чем обучена. Агент может вызвать калькулятор, запросить данные из базы или обратиться к внешнему API.

Вот три ключевых компонента любого агента:

Важный момент: даже если инструмент один — передавай его в список. LangChain требует именно список tools, не отдельный объект.

from langchain.agents import create_tool_calling_agent, AgentExecutor

# tools всегда список, даже если инструмент один
tools = [my_calculator_tool]
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

Как создать инструмент правильно

Частая ошибка — пропустить docstring. LangChain использует описание функции, чтобы объяснить агенту, когда и зачем вызывать инструмент. Без docstring create_tool_calling_agent выбросит ошибку.

from langchain.tools import tool

@tool
def get_weather(city: str) -> str:
    """Возвращает текущую погоду для указанного города.
    Используй этот инструмент, когда пользователь спрашивает о погоде."""
    # здесь реальный запрос к API погоды
    return f"В {city} сейчас +18°C, облачно"

Агент не вызовет инструмент, если не поймет его назначение из docstring. Чем точнее описание — тем лучше выборка.

Что такое RAG и как он работает

RAG (Retrieval-Augmented Generation) — это способ подключить модель к своей базе знаний. Модель не додумывает из обучающих данных, а сначала ищет релевантные фрагменты в твоих документах, потом генерирует ответ на их основе.

Схема простая: документы -> чанки -> векторное хранилище -> retriever -> LLM.

Критически важный промт для предотвращения галлюцинаций:

If you don't know the answer based on the provided context, just say "I don't know".

Эта инструкция останавливает модель от придумывания. Без неё даже хороший RAG начинает выдавать красиво звучащую неправду.

Размер чанков и overlap

Два параметра, которые сильнее всего влияют на качество поиска:

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,     # символов в чанке
    chunk_overlap=200    # пересечение соседних чанков
)

chunk_overlap создает скользящее окно между чанками. Если информация разрезается на границе — overlap сохраняет контекст в обоих кусках. Без него часть ответов будет обрезана.

На практике: для технической документации chunk_size 800-1200 работает лучше всего. Для коротких FAQ-статей — 400-600.

Пошаговый туториал: агент с RAG на Python

Ниже полный рабочий пример. Агент принимает вопросы, ищет ответы в загруженных документах и использует LLM только для формулировки ответа.

Шаг 1. Установка зависимостей

pip install langchain langchain-openai langchain-community faiss-cpu beautifulsoup4

Шаг 2. Загрузка и разбивка документов

from langchain_community.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import bs4

# Загружаем данные с сайта
loader = WebBaseLoader(
    web_paths=["https://vibecoderz.ru/blog/"],
    bs_kwargs=dict(
        parse_only=bs4.SoupStrainer(
            class_=("post-content", "post-title", "post-header")
        )
    ),
)
docs = loader.load()

# Разбиваем на чанки
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = splitter.split_documents(docs)

Шаг 3. Векторное хранилище

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

Шаг 4. RAG цепочка с промтом

from langchain_openai import ChatOpenAI
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.4)

system_prompt = """Ты — помощник по вайбкодингу.
Отвечай только на основе предоставленного контекста.
Если не знаешь ответа — скажи об этом прямо.

Контекст: {context}"""

prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    ("human", "{input}"),
])

question_answer_chain = create_stuff_documents_chain(llm, prompt)
rag_chain = create_retrieval_chain(retriever, question_answer_chain)

Шаг 5. Запуск

response = rag_chain.invoke({"input": "Какие AI IDE лучше всего для новичков?"})
print(response["answer"])

Память в агенте: как работает и когда сбрасывать

Без памяти агент не помнит предыдущих сообщений. Каждый запрос — как первый. Для чат-бота это катастрофа.

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

agent_with_memory = RunnableWithMessageHistory(
    rag_chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

Для многопользовательских приложений (например, Telegram-бот) session_id — это ID чата пользователя. Каждый пользователь получает изолированную историю, чужие сообщения не смешиваются.

Чтобы сбросить историю конкретной сессии:

store["user_123"].clear()

Настройка temperature: для агентов оптимальный диапазон — 0.4-0.6. Слишком низкая температура парадоксально увеличивает расход токенов: модель начинает дольше «думать» перед ответом. Слишком высокая — теряет точность на фактических вопросах.

LangGraph: для нетривиальных агентов

LangGraph — это библиотека поверх LangChain для построения агентов как графов. Каждая функция или LLM-вызов — это вершина (node), передача данных между ними — ребра (edges).

Ключевое отличие от AgentExecutor: в LangGraph у тебя полный контроль над тем, что происходит на каждом шаге. Можно добавить человека в петлю (human-in-the-loop), сделать условную логику, распараллелить шаги.

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    approval: str

def research_node(state: AgentState):
    # LLM ищет информацию
    result = llm.invoke(state["messages"])
    return {"messages": [result], "approval": ""}

def check_approval(state: AgentState):
    # условная логика: продолжать или нет
    if state["approval"] == "yes":
        return "summarize"
    return "research"

graph = StateGraph(AgentState)
graph.add_node("research", research_node)
graph.add_conditional_edges("research", check_approval, {
    "research": "research",
    "summarize": "summarize"
})

Состояние (state) в LangGraph — это общий «блокнот», который видят все ноды. Думай о нем как о контексте всего пайплайна.

Structured Output для надежного парсинга

Чтобы LLM возвращал JSON вместо произвольного текста, используй Pydantic:

from pydantic import BaseModel
from langchain_openai import ChatOpenAI

class ResearchResult(BaseModel):
    title: str
    summary: str
    confidence: float

llm = ChatOpenAI(model="gpt-4o-mini")
structured_llm = llm.with_structured_output(ResearchResult)

result = structured_llm.invoke("Исследуй тему: LangGraph в production")
print(result.title)   # прямой доступ к полям без парсинга

Это надежнее, чем просить модель ответить в формате JSON — Pydantic гарантирует структуру на уровне типов.

Сравнение подходов: когда что выбирать

Совет из реальной практики: если нода агента работает с большим объемом данных (1000+ страниц), не загружай всё в один контекст. Разбивай на этапы: первый агент делает резюме по каждому документу, второй — резюме резюме. Качество результата заметно лучше.

Деплой: от кода до рабочего сервиса

Для простого деплоя через FastAPI:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Query(BaseModel):
    question: str
    session_id: str

@app.post("/ask")
async def ask(query: Query):
    response = agent_with_memory.invoke(
        {"input": query.question},
        config={"configurable": {"session_id": query.session_id}}
    )
    return {"answer": response["answer"]}

Для продакшена добавь Redis для хранения истории вместо in-memory словаря — иначе при перезапуске сервера все сессии сбросятся.

LangSmith помогает отслеживать каждый вызов агента: видно, какие инструменты вызывались, сколько токенов потрачено, где возникли ошибки. Для дебага production-агентов незаменим.

Выбор модели под задачу

Для начала — Gemini Flash через OpenRouter. Когда агент заработает, переходи на Claude Sonnet 4.6 или GPT-5.4 для продакшена: они значительно надежнее вызывают инструменты и реже галлюцинируют в RAG.

Типичные ошибки и как их избежать

Нет docstring у инструмента. LangChain не понимает, когда вызывать инструмент. Всегда добавляй описание — конкретное, без воды.

Температура слишком низкая. При temperature=0 агент на простых задачах тратит больше токенов, чем при 0.4-0.6. Проверено на практике.

Нет chunk_overlap в RAG. Информация на границах чанков теряется. Минимальный overlap — 10-20% от chunk_size.

Один инструмент передан не как список. tools=my_tool вместо tools=[my_tool] — частая ошибка у новичков.

Смешиваются сессии разных пользователей. В Telegram-боте обязательно используй session_id = str(message.chat.id), иначе история одного пользователя попадет другому.

FAQ

Чем LangChain отличается от простого вызова API OpenAI?
LangChain добавляет оркестрацию: память, инструменты, RAG, цепочки вызовов. Прямой API-вызов — это один запрос и один ответ. LangChain позволяет строить системы с логикой и состоянием.

Нужен ли LangGraph для простого агента?
Нет. Для базового агента с 2-3 инструментами хватает create_tool_calling_agent. LangGraph нужен, когда логика становится нелинейной: условные переходы, параллельные ноды, human-in-the-loop.

Можно ли использовать LangChain без OpenAI?
Да. LangChain поддерживает любую модель через адаптеры: Claude, Gemini, DeepSeek, Mistral. OpenRouter дает доступ к десяткам моделей через одно API.

Какой векторный стор выбрать для продакшена?
FAISS хорош для локальной разработки и небольших объемов. Для продакшена — Qdrant, Weaviate или Pinecone. Они поддерживают горизонтальное масштабирование и метадата-фильтры.

Как контролировать расходы на токены?
Устанавливай max_tokens на уровне модели, добавляй verbose=False в AgentExecutor чтобы убрать лишние логи, используй более дешевые модели для простых задач (DeepSeek V3.2 за $0.28/1M токенов).

Как избежать галлюцинаций в RAG?
Добавь в системный промт: «Если ответ отсутствует в контексте — скажи об этом прямо». Не позволяй модели додумывать. Это единственный надежный способ.

Работает ли LangChain с русским языком?
Да, но качество embedding для русского текста ниже. Для лучших результатов используй модели с мультиязычными embedding (text-embedding-3-large от OpenAI или multilingual-e5).

Глоссарий

LangChain — Python-фреймворк для создания приложений на основе LLM. Предоставляет инструменты для цепочек, агентов, памяти и RAG.

LangGraph — библиотека для построения агентов как направленных графов. Позволяет описывать сложную логику с ветвлениями и циклами.

RAG (Retrieval-Augmented Generation) — подход, при котором LLM сначала ищет релевантную информацию в базе знаний, затем генерирует ответ на её основе.

Agent — LLM, способный принимать решения о вызове внешних инструментов для выполнения задачи.

Tool — функция, которую агент может вызвать. Примеры: поиск в интернете, калькулятор, запрос к API.

Vector Store — база данных для хранения векторных представлений текста. Позволяет искать документы по смысловой близости.

Embedding — числовое представление текста в векторном пространстве. Похожие по смыслу тексты имеют близкие векторы.

Chunk — фрагмент документа после разбивки. Размер чанка влияет на точность поиска в RAG.

Session ID — уникальный идентификатор сессии пользователя. Используется для изоляции истории диалогов.

LangSmith — платформа для мониторинга и дебага LangChain приложений. Показывает трассировку каждого вызова.

С чего начать прямо сейчас

Если ты ещё не пробовал LangChain — начни с самого простого: установи библиотеку, получи бесплатный ключ через OpenRouter (модель Gemini Flash), и запусти базовый RAG на своих документах. Это займет полтора часа, не больше.

Для тех, кто уже работает с LangChain, следующий шаг — перейти с AgentExecutor на LangGraph. Разница в контроле над логикой огромная, и в production это ощущается.

Посмотри каталог AI-инструментов — там собраны все актуальные IDE и ассистенты, с которыми LangChain интегрируется лучше всего. Отдельные обзоры есть на Claude Code, Cursor и GitHub Copilot.

Если строишь агента под конкретную задачу и хочешь разобрать архитектуру — запишись на консультацию к Максиму. Разберем стек, чанкинг, выбор модели и схему деплоя под твой кейс.

Обновлено: март 2026