Ваш RAG не умеет думать. А мой умеет

Базовые RAG-системы уже научились неплохо справляться с прямыми вопросами по тексту. Но только если ответ лежит в одном конкретном абзаце, а вопрос сформулирован почти так же, как сам исходный документ. Попробуйте заставить систему связать факты из трёх разных источников или сделать банальный логический вывод. В большинстве случаев результат будет неутешительным. А уж про поиск скрытых связей я даже спрашивать боюсь.

Сегодня рассмотрим open-source RAG-фреймворк HippoRAG 2. В сфере RAG главным преимуществом данного фреймворка является качество ответов, потому что принципы его работы основаны на реальном человеческом мозге. Давайте разберёмся, откуда он взялся, как устроен изнутри и как его запустить.

Принципы работы

Префикс «Hippo» в названии — это отсылка к гиппокампу, структуре мозга, которая отвечает за формирование и извлечение долговременных воспоминаний. 

Разработчики из Ohio State University взяли за основу теорию гиппокампального индексирования Тейлера и Дисченна. Согласно ей, мозг хранит не сами воспоминания целиком, а лишь некоторые связи между ними, и при запросе восстанавливает полную картину через цепочку ассоциаций. 

В архитектуре HippoRAG каждый компонент соответствует своему нейробиологическому аналогу:

• LLM играет роль неокортекса. Отвечает за извлечение структурированных представлений из текста. 

• Retrieval-энкодер берёт на себя функцию парагиппокампальных областей мозга, обнаруживая семантические связи. 

• Knowledge граф вместе с алгоритмом PPR (Personalized PageRank) имитирует сам гиппокамп. Он хранит сеть знаний и фактов и умеет строить в ней ассоциативные цепочки при поиске.

В HippoRAG подобный механизм долговременной памяти позволяет выявить скрытые связи между фактами. Речь идёт о многошаговом рассуждении (multi-hop reasoning). Это процесс, при котором система последовательно сопоставляет факты из разных источников по контексту и выстраивает цепочку связей, чтобы ответить на абстрактный вопрос.

Факты внутри системы называются триплетами. Это структурированное представление знаний в виде «субъект — отношение — объект». 

К примеру:

• (Оливер Бэдмен, является, политик).

  Или:

•  (Монтебелло, часть округа, Рокленд Каунти).

За извлечение триплетов отвечает OpenIE (Open Information Extraction) с помощью LLM. При индексации фреймворк отправляет каждый чанк документа в языковую модель с инструкцией извлечь все структурированные утверждения в виде троек. Результаты кэшируются в openie_cache/, чтобы при повторном запуске не тратить токены снова.

Зачем это нужно? Потому что для многошагового вопроса вроде: «В каком округе родился политик, который…» — обычный RAG просто найдёт документ про политика и отдельно про округ, а связь не уловит. А HippoRAG 2 склеивает два триплета через общую сущность (политик ? место рождения ? округ). Это и есть так называемая «скрытая связь».

Из всех извлечённых триплетов строится knowledge граф. Не такой огромный, как в GraphRAG, а более компактный(HippoRAG на датасете MuSiQue использует около 9 млн токенов — против 115 млн у GraphRAG).

При загрузке документов помимо создания эмбеддингов для чанков проводится извлечение упомянутых триплетов. Из извлечённых фактов строится knowledge-граф. Соответственно, при ответе на вопрос используется как стандартный проход по эмбеддированным документам с косинусным подобием, так и ранжирование фактов по графу. В этот момент задействуется PPR алгоритм. PPR — это вариация PageRank, где вместо случайного блуждания по всему графу, релевантность узлов измеряется относительно конкретного набора начальных (seed) узлов.

Установка и первый запуск

Установить фреймворк можно через pip или клонировав репозиторий.

conda create -n hipporag python=3.10 conda activate hipporag pip install hipporag 

Далее — пара экспортов (API-ключи и пути к кэшу) из env:

export OPENAI_API_KEY="sk-..." export HF_HOME="/путь/к/кэшу" 

Допустим, у нас есть три документа:

from hipporag import HippoRAG  docs = [     "Oliver Badman is a politician.",     "Montebello is a part of Rockland County.",     "Erik Hort's birthplace is Montebello." ]  hipporag = HippoRAG(     save_dir="my_rag_memory",    # сюда упадёт всё: эмбеддинги, граф, кэш     llm_model_name="gpt-4o-mini",         llm_api_key = OPENAI_API_KEY,     llm_base_url = OPENAI_BASE_URL,     embedding_model_name="nvidia/NV-Embed-v2",     embedding_api_key = EMBEDDING_API_KEY,     embedding_base_url = EMBEDDING_BASE_URL      ) 

Кстати говоря, фреймворк позволяет переопределять base_url для работы с локальными серверами. То есть ничто не мешает поднять собственные FastAPI-серверы с локальными LLM и моделями эмбеддингов или в Google Colab, используя библиотеку transformers, и затем просто указать эндпоинты с их выводом в openai-совместимом формате.

Пример эмбеддинг-модели

Ниже — самописный FastAPI-сервер для эмбеддингов.

import torch from fastapi import FastAPI, HTTPException from pydantic import BaseModel from transformers import AutoTokenizer, AutoModel from typing import List import uvicorn  class EmbeddingRequest(BaseModel):     input: List[str] | str               model: str                          encoding_format: str = "float"    class EmbeddingResponse(BaseModel):     object: str = "list"     data: List[dict]     model: str     usage: dict  MODEL_NAME = "название вашей модели"   device = "cuda" if torch.cuda.is_available() else "cpu"  tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME) model = AutoModel.from_pretrained(MODEL_NAME).to(device) model.eval()  def embed_texts(texts: List[str]) -> List[List[float]]:     inputs = tokenizer(         texts,         padding=True,         truncation=True,         return_tensors="pt",         max_length=512     ).to(device)      with torch.no_grad():         outputs = model(**inputs)         embeddings = outputs.last_hidden_state.mean(dim=1)      return embeddings.cpu().numpy().tolist()  app = FastAPI(title="Local Embedding Server (OpenAI-compatible)")  @app.get("/v1/models") async def list_models():     return {         "object": "list",         "data": [             {                 "id": MODEL_NAME,                 "object": "model",                 "owned_by": "local",                 "permission": []             }         ]     }  @app.post("/v1/embeddings") async def create_embedding(request: EmbeddingRequest):     texts = [request.input] if isinstance(request.input, str) else request.input      if not texts:         raise HTTPException(status_code=400, detail="Input text list is empty")      try:         embeddings = embed_texts(texts)     except Exception as e:         raise HTTPException(status_code=500, detail=f"Embedding failed: {str(e)}")      response_data = []     for idx, emb in enumerate(embeddings):         response_data.append({             "object": "embedding",             "index": idx,             "embedding": emb         })      return EmbeddingResponse(         data=response_data,         model=MODEL_NAME,         usage={             "prompt_tokens": sum(len(t) for t in texts),             "total_tokens": sum(len(t) for t in texts)         }     )  if __name__ == "__main__":     uvicorn.run(app, host="0.0.0.0", port=8001) 

Теперь этот сервер можно передать в embedding_base_url="http://localhost:8001/v1".

Более простой и производительный вариант — использовать SentenceTransformer. Сервер остаётся полностью совместимым с OpenAI API.

import asyncio from contextlib import asynccontextmanager from typing import List, Union  from fastapi import FastAPI, HTTPException from pydantic import BaseModel from sentence_transformers import SentenceTransformer import uvicorn  class EmbeddingRequest(BaseModel):     input: Union[str, List[str]]       model: str       encoding_format: str = "float"  class EmbeddingResponse(BaseModel):     object: str = "list"     data: List[dict]     model: str     usage: dict  @asynccontextmanager async def lifespan(app: FastAPI):     app.state.model = SentenceTransformer("intfloat/e5-large-v2", device="cuda")     yield     app.state.model = None  app = FastAPI(title="Local Embedding Server (OpenAI-compatible)", lifespan=lifespan)  @app.get("/v1/models") async def list_models():     return {         "object": "list",         "data": [             {                 "id": "local-embedding-model",                 "object": "model",                 "owned_by": "local",                 "permission": []             }         ]     }  @app.post("/v1/embeddings") async def create_embedding(request: EmbeddingRequest):     texts = [request.input] if isinstance(request.input, str) else request.input      if not texts:         raise HTTPException(status_code=400, detail="Input text list is empty")      model: SentenceTransformer = app.state.model     try:         embeddings = model.encode(texts, normalize_embeddings=True)     except Exception as e:         raise HTTPException(status_code=500, detail=f"Embedding failed: {str(e)}")      response_data = [         {             "object": "embedding",             "index": idx,             "embedding": emb.tolist()         }         for idx, emb in enumerate(embeddings)     ]      return EmbeddingResponse(         data=response_data,         model=request.model,         usage={             "prompt_tokens": sum(len(text.split()) for text in texts),             "total_tokens": sum(len(text.split()) for text in texts)         }     )  if __name__ == "__main__":     uvicorn.run(app, host="0.0.0.0", port=8001) 

Индексация документов

Индексация запускается одной командой:

hipporag.index(docs=docs)

Что происходит внутри? 

• Документы режутся на чанки (стандартно — по предложениям).

• Каждый чанк эмбеддится.

• Одновременно LLM обрабатывает каждый чанк через OpenIE и извлекает из него все смысловые триплеты.

• Триплеты превращаются в узлы и рёбра knowledge-графа.

• Эмбеддинги узлов графа тоже вычисляются (чтобы потом искать похожие факты). 

Где хранится?

В папке my_rag_memory (которую мы передали в save_dir) создаётся структура: 

• embeddings/ — плоские файлы с эмбеддингами чанков и узлов графа (обычно .npy или через faiss индекс). 

• graph/ — сериализованный граф (узлы, рёбра, веса). 

• openie_cache/ — результаты извлечения триплетов, чтобы при повторном запуске не жечь токены заново.

На данном этапе фреймворк хранит эмбеддинги в формате .parquet. Но ничего не мешает дописать совместимость с векторными БД, особенно в наше время.

Важный нюанс: если вы перезапускаете индекс с теми же документами, HippoRAG 2 не будет заново дёргать OpenIE и LLM, а проверит кэш по хешу текста. Так что за токены, хотя бы тут, можете не переживать.

Что возвращает каждая функция?

retrieve — поиск без генерации ответа:

results = hipporag.retrieve(     queries=["What county is Erik Hort's birthplace a part of?"],     num_to_retrieve=2 ) print(results) 

На выходе — список списков. Для каждого запроса: 

[     [          {"text": "Montebello is a part of Rockland County.", "score": 0.92, "type": "chunk"},         {"text": "Erik Hort's birthplace is Montebello.", "score": 0.87, "type": "chunk"}     ] ] 

Важный момент: type может быть "chunk" (найденный чанк) или "fact" (найденный триплет из графа) — зависит от того, что победило в ранжировании.

rag_qa — выполняет полный цикл: поиск ? передача найденного контекста в LLM ? генерация ответа

answers = hipporag.rag_qa(     queries=["What county is Erik Hort's birthplace a part of?"] ) print(answers) 

Вернёт список строк с ответами, например: ["Rockland County"]. В ответе также возвращается список использованных чанков.

Оценка с gold-данными

Один из самых приятных моментов, это когда у вас есть золотые ответы и поддерживающие документы для оценки:

gold_answers = [["Rockland County"]] gold_docs = [     ["Montebello is a part of Rockland County.",      "Erik Hort's birthplace is Montebello."] ]  eval_results = hipporag.rag_qa(     queries=queries,     gold_docs=gold_docs,     gold_answers=gold_answers ) 

Тогда в eval_results упадёт словарь с метриками: 

• "retrieval_hit_rate" (попали ли нужные чанки в топ-N), 

• "answer_accuracy" (точность ответа, часто через F1 или EM), 

• "latency_seconds" — чтобы потом бенчмаркать.

Удаление и добавление документов

Если понадобится удалить документ, есть hipporag.delete_docs(doc_indices=[0,2]).

Граф перестраивается инкрементально, не с нуля. Для добавления новых данных вызывается hipporag.index(docs=new_docs). Система сама определит, что уже проиндексировано, а что нет.

Заключение

Признаюсь, я обожаю HippoRAG 2. Для меня это максимально удобный инструмент, который ещё и справляется лучше своих аналогов. Естественно, он не универсальная затычка для любой проблемы, но в задачах контекста, рассыпанного по множеству документов, ему нет равных.

Я советую обратить внимание на фреймворк уже за то, что авторам удалось решить задачу ассоциативного рассуждения без многократного роста стоимости запросов. Это ли не чудо?

© 2026 ООО «МТ ФИНАНС»

Телеграм: t.me/ainewsline

Источник: habr.com

Комментарии: