LangChain в России

# Базовый пакет
pip install langchain

# Интеграция с OpenAI-совместимыми API
pip install langchain-openai

# Для работы с документами
pip install langchain-community

# Для векторных хранилищ
pip install faiss-cpu  # или faiss-gpu для GPU

from langchain_openai import ChatOpenAI

# Настройка LLM через AITUNNEL
llm = ChatOpenAI(
    model="gpt-5.2",
    api_key="sk-aitunnel-xxx",
    base_url="https://api.aitunnel.ru/v1/",
    temperature=0.7,
    max_tokens=4096
)

# Простой запрос
response = llm.invoke("Привет! Что такое LangChain?")
print(response.content)

# Streaming
for chunk in llm.stream("Расскажи длинную историю"):
    print(chunk.content, end="", flush=True)

from langchain_openai import OpenAIEmbeddings

# Embeddings для векторного поиска
embeddings = OpenAIEmbeddings(
    model="text-embedding-3-small",
    api_key="sk-aitunnel-xxx",
    base_url="https://api.aitunnel.ru/v1/"
)

# Получение вектора для текста
vector = embeddings.embed_query("Пример текста")
print(f"Размерность вектора: {len(vector)}")

# Batch embeddings
vectors = embeddings.embed_documents([
    "Документ 1",
    "Документ 2",
    "Документ 3"
])

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. Загрузка документов
loader = TextLoader("./data/document.txt")
documents = loader.load()

# 2. Разбиение на чанки
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
splits = text_splitter.split_documents(documents)

# 3. Создание векторного хранилища
embeddings = OpenAIEmbeddings(
    model="text-embedding-3-small",
    api_key="sk-aitunnel-xxx",
    base_url="https://api.aitunnel.ru/v1/"
)
vectorstore = FAISS.from_documents(splits, embeddings)

# 4. Настройка LLM
llm = ChatOpenAI(
    model="gpt-5.2",
    api_key="sk-aitunnel-xxx",
    base_url="https://api.aitunnel.ru/v1/"
)

# 5. Создание RAG chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5})
)

# 6. Запрос
answer = qa_chain.invoke({"query": "Какие основные темы в документе?"})
print(answer["result"])

from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory

# Память для хранения истории
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# Conversational RAG
qa_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=vectorstore.as_retriever(),
    memory=memory
)

# Диалог с памятью
response1 = qa_chain.invoke({"question": "Что такое RAG?"})
response2 = qa_chain.invoke({"question": "А какие есть альтернативы?"})

from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate

# Определение инструментов
@tool
def search_web(query: str) -> str:
    """Поиск информации в интернете"""
    # Здесь была бы реальная реализация
    return f"Результаты поиска для: {query}"

@tool
def calculate(expression: str) -> str:
    """Вычисление математических выражений"""
    try:
        result = eval(expression)
        return f"Результат: {result}"
    except:
        return "Ошибка вычисления"

@tool
def get_weather(city: str) -> str:
    """Получение погоды в городе"""
    return f"Погода в {city}: +20°C, солнечно"

# Промпт для агента
prompt = ChatPromptTemplate.from_messages([
    ("system", "Ты полезный ассистент. Используй инструменты для ответа на вопросы."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

# Создание агента
tools = [search_web, calculate, get_weather]
agent = create_openai_tools_agent(llm, tools, prompt)

# Executor для запуска
executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,  # Показывать ход мыслей
    max_iterations=5
)

# Запуск
result = executor.invoke({
    "input": "Какая погода в Москве и сколько будет 25 * 4?"
})
print(result["output"])

from langchain.agents import AgentExecutor
from langgraph.prebuilt import create_react_agent

# Агент-исследователь
researcher = create_react_agent(
    llm, 
    [search_web],
    state_modifier="Ты исследователь. Находи информацию."
)

# Агент-писатель
writer = create_react_agent(
    llm,
    [],
    state_modifier="Ты писатель. Создавай контент на основе данных."
)

# Orchestration через LangGraph
# (требует pip install langgraph)

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Цепочка: промпт -> LLM -> парсер
chain = (
    ChatPromptTemplate.from_template("Переведи на английский: {text}")
    | llm
    | StrOutputParser()
)

result = chain.invoke({"text": "Привет, мир!"})
print(result)  # "Hello, world!"

# Параллельные цепочки
from langchain_core.runnables import RunnableParallel

parallel_chain = RunnableParallel(
    translation=ChatPromptTemplate.from_template("Переведи: {text}") | llm,
    summary=ChatPromptTemplate.from_template("Резюмируй: {text}") | llm
)

results = parallel_chain.invoke({"text": "Длинный текст..."})

from langchain_community.document_loaders import (
    TextLoader,
    PDFLoader,
    CSVLoader,
    JSONLoader,
    WebBaseLoader,
    GitLoader
)

# Текстовые файлы
docs = TextLoader("file.txt").load()

# PDF
docs = PDFLoader("document.pdf").load()

# CSV
docs = CSVLoader("data.csv").load()

# Веб-страницы
docs = WebBaseLoader("https://example.com").load()

# Git репозиторий
docs = GitLoader(
    clone_url="https://github.com/user/repo",
    branch="main"
).load()

from langchain.memory import (
    ConversationBufferMemory,
    ConversationSummaryMemory,
    ConversationBufferWindowMemory
)

# Полная история
memory = ConversationBufferMemory()

# Только последние N сообщений
memory = ConversationBufferWindowMemory(k=10)

# Суммаризация истории
memory = ConversationSummaryMemory(llm=llm)