Files
buryan-infra/ops/bots/hub/agent.py
T
buryan-agent 03d20b95db Агент по графу: понимает вопросы словами, без LLM
agent.py разбирает фразу в план (намерение, персона, жанр, тема, эпоха,
оценка) и выполняет запрос. Словарь берётся из графа, поэтому агент знает
только то, что есть в медиатеке.

Понимает русские синонимы (фантастика → science fiction, искусственный
интеллект → artificial intelligence, робот → robot) и транслитерацию имён
(«фильмы Нолана» → Christopher Nolan). Эпохи в любом виде, оценки по словам.

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

Вызовы: команда «агент», свободный текст Медиа-бота, и «найди» с падением
в граф, когда в Jellyfin пусто.

Проверено: Нолан → Interstellar; ИИ по десятилетиям (1980-е 1, 1990-е 1,
2000-е 2, 2010-е 2); похоже на Дюну → 8 фильмов; высокорейтинговые 80-х →
Blade Runner; «найди про роботов с рейтингом» → 7 фильмов.

Попутно: /pick получил фильтры по персоне и оценке; /compare сравнивает
книгу и фильм (общие и разные жанры, автор, связь экранизации); поиск ядра
понимает русские окончания (Дюну → Dune).

Ловушки: явная команда первым словом (иначе «похоже» перехватывало запрос),
порог основы для коротких слов, и восстановление аналитических функций,
случайно срезанных при замене do_pick.
2026-10-20 11:39:22 +03:00

335 lines
13 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Агент по графу: понимает фразу, строит план и выполняет запросы.
Работает без LLM: словарь берётся из самого графа (персоны, жанры, темы,
десятилетия), поэтому агент знает ровно то, что есть в медиатеке.
"""
import json
import re
import time
import urllib.error
import urllib.parse
import urllib.request
CORE = "http://127.0.0.1:9120"
CACHE = {"at": 0, "vocab": None}
TTL = 300
def _get(path, params=None, timeout=15):
url = CORE + path
if params:
url += "?" + urllib.parse.urlencode(params)
try:
with urllib.request.urlopen(url, timeout=timeout) as r:
return json.loads(r.read() or b"{}"), None
except Exception as e:
return None, str(e)[:120]
def vocab():
"""Словарь графа: персоны, жанры, темы, эпохи."""
if CACHE["vocab"] and time.time() - CACHE["at"] < TTL:
return CACHE["vocab"]
v = {"persons": [], "genres": [], "themes": [], "decades": []}
for kind, key in (("актёр", "persons"), ("режиссёр", "persons"),
("композитор", "persons"), ("жанр", "genres"),
("тема", "themes"), ("эпоха", "decades")):
data, _ = _get("/entities", {"kind": kind, "limit": 500})
for it in (data or {}).get("items") or []:
v[key].append(it.get("title"))
v["persons"] = sorted(set(v["persons"]))
v["genres"] = sorted(set(v["genres"]))
v["themes"] = sorted(set(v["themes"]))
v["decades"] = sorted(set(v["decades"]))
CACHE.update({"at": time.time(), "vocab": v})
return v
# ── русские синонимы тем и жанров графа ──
RU_THEMES = {
"искусственн": "artificial intelligence",
"интеллект": "artificial intelligence",
"робот": "robot",
"андроид": "android",
"космос": "space",
"космическ": "space",
"будущ": "future",
"антиутоп": "dystopia",
"постапокал": "post-apocalyptic",
"время": "time travel",
"путешеств": "time travel",
"инопланет": "alien",
"чужой": "alien",
"монстр": "monster",
"катастроф": "disaster",
"война": "war",
"супергеро": "superhero",
"магия": "magic",
"детектив": "detective",
"любов": "love",
"месть": "revenge",
"школ": "school",
"зомби": "zombie",
"вампир": "vampire",
"дракон": "dragon",
"рыцар": "knight",
"пират": "pirate",
}
RU_GENRES = {
"фантастик": "science fiction",
"фэнтези": "fantasy",
"фентези": "fantasy",
"ужас": "horror",
"хоррор": "horror",
"комеди": "comedy",
"драм": "drama",
"боевик": "action",
"триллер": "thriller",
"детектив": "mystery",
"приключен": "adventure",
"мелодрам": "romance",
"документальн": "documentary",
"анимаци": "animation",
}
TRANSLIT = {
"а": "a", "б": "b", "в": "v", "г": "g", "д": "d", "е": "e", "ё": "e",
"ж": "zh", "з": "z", "и": "i", "й": "y", "к": "k", "л": "l", "м": "m",
"н": "n", "о": "o", "п": "p", "р": "r", "с": "s", "т": "t", "у": "u",
"ф": "f", "х": "h", "ц": "ts", "ч": "ch", "ш": "sh", "щ": "sch",
"ъ": "", "ы": "y", "ь": "", "э": "e", "ю": "yu", "я": "ya",
}
def translit(text):
return "".join(TRANSLIT.get(ch, ch) for ch in (text or "").lower())
def match_person(text, persons):
"""Ищем персону: латиницей напрямую или через транслитерацию."""
low = text.lower()
for p in persons:
if p and p.lower() in low:
return p
tr = translit(text)
best = None
for p in persons:
for token in (p or "").lower().split():
if len(token) < 4:
continue
stem = token[:5]
if stem and stem in tr:
best = p
break
if best:
break
return best
def match_by_dict(text, mapping, vocabulary):
"""Русское слово → английское значение из словаря графа."""
low = text.lower()
for ru, en in mapping.items():
if ru in low:
for v in vocabulary:
if v and en.lower() in v.lower():
return v
return None
def _contains_any(text, words):
low = text.lower()
return any(w in low for w in words)
def parse(text, v=None):
"""План: что понял агент."""
v = v or vocab()
low = text.lower()
plan = {"raw": text, "intent": None, "person": None, "genre": None,
"theme": None, "decade": None, "rating": None, "targets": []}
# интент
if _contains_any(low, ("сравн", "общего", "отлича")):
plan["intent"] = "compare"
elif _contains_any(low, ("когда", "динамик", "по годам", "десятилет")):
plan["intent"] = "timeline"
elif _contains_any(low, ("кто снимал", "кто снял", "с кем", "фильмы с", "фильмография")):
plan["intent"] = "person"
elif _contains_any(low, ("похож", "как ", "вроде")):
plan["intent"] = "similar"
else:
plan["intent"] = "pick"
# персона: латиница или транслитерация
plan["person"] = match_person(text, v["persons"])
# эпоха
m = re.search(r"(19|20)\d{2}", text)
if m:
plan["decade"] = str((int(m.group(0)) // 10) * 10) + "-е"
else:
m2 = re.search(r"\b(\d{2})\s*(?:-?е|-?х|ые|ых)\b", text)
if m2:
two = int(m2.group(1))
year = (1900 + two) if two >= 30 else (2000 + two)
plan["decade"] = str((year // 10) * 10) + "-е"
# жанр: прямое совпадение или русский синоним
genre = None
for g in v["genres"]:
if g and g.lower() in low:
genre = g
break
if not genre:
genre = match_by_dict(text, RU_GENRES, v["genres"])
plan["genre"] = genre
# тема: прямое совпадение или русский синоним
theme = None
for t in sorted(v["themes"], key=len, reverse=True):
if len(t) > 4 and t.lower() in low:
theme = t
break
if not theme:
theme = match_by_dict(text, RU_THEMES, v["themes"])
plan["theme"] = theme
# оценка
if _contains_any(low, ("высок", "отличн", "8+", "лучш", "топ")):
plan["rating"] = "высокая"
elif _contains_any(low, ("неплох", "хорош", "7+")):
plan["rating"] = "хорошая"
# цели для сравнения/похожего: всё, что похоже на название
for token in re.findall(r"«([^»]+)»|\"([^\"]+)\"", text):
t = token[0] or token[1]
if t:
plan["targets"].append(t)
if not plan["targets"]:
m3 = re.search(r"(?:похож\w*\s+на|вроде|как)\s+(.+)", text, re.IGNORECASE)
if m3:
plan["targets"].append(m3.group(1).strip().strip(".,!?"))
return plan
def describe(plan):
parts = []
names = {"pick": "подбор", "person": "фильмография", "timeline": "по десятилетиям",
"similar": "похожее", "compare": "сравнение"}
parts.append("намерение: " + names.get(plan["intent"], plan["intent"]))
for key, label in (("person", "персона"), ("genre", "жанр"), ("theme", "тема"),
("decade", "эпоха"), ("rating", "оценка")):
if plan.get(key):
parts.append(label + ": " + str(plan[key]))
return ", ".join(parts)
def run(text):
"""Выполнить запрос. Возвращает (ответ, план)."""
v = vocab()
plan = parse(text, v)
intent = plan["intent"]
if intent == "pick":
params = {"limit": 10}
for key in ("genre", "theme", "decade", "rating", "person"):
if plan.get(key):
params[key] = plan[key]
data, err = _get("/pick", params)
if err:
return "Не смог получить данные: " + err, plan
items = (data or {}).get("items") or []
relaxed = []
for key in ("rating", "theme", "genre", "decade", "person"):
if items or key not in params:
continue
del params[key]
relaxed.append(key)
data, err = _get("/pick", params)
if err:
break
items = (data or {}).get("items") or []
if not items:
return "По таким условиям в медиатеке ничего нет.", plan
plan["relaxed"] = relaxed
lines = ["Нашёл " + str(len(items)) + ":", ""]
if plan.get("relaxed"):
lines.insert(0, "_условия ослаблены: убрал " + ", ".join(plan["relaxed"]) + "_")
for i in items:
parts = [str(i.get("title"))]
if i.get("rating"):
parts.append(str(i.get("rating")))
if i.get("genres"):
parts.append(str(i.get("genres")))
lines.append("• " + " — ".join(parts))
return "\n".join(lines), plan
if intent == "person":
if not plan["person"]:
return "Не понял, кто имеется в виду. Назовите имя.", plan
data, err = _get("/person", {"q": plan["person"]})
if err or not data:
return "Персону не нашёл.", plan
films = data.get("films") or []
lines = ["**" + str(plan["person"]) + "**, фильмов: " + str(len(films)), ""]
for f in films[:15]:
lines.append("• " + str(f.get("title")))
return "\n".join(lines), plan
if intent == "timeline":
node = plan.get("theme") or plan.get("genre")
if not node:
return "Укажите тему или жанр: например «когда были фильмы про искусственный интеллект».", plan
kind = "тема" if plan.get("theme") else "жанр"
data, err = _get("/timeline", {"q": node, "kind": kind})
if err or not data:
return "Не нашёл такую тему.", plan
lines = ["**" + str(node) + " по десятилетиям**", ""]
for d in data.get("decades") or []:
lines.append("• " + str(d.get("decade")) + " — " + str(d.get("n")))
return "\n".join(lines), plan
if intent == "similar":
target = plan["targets"][0] if plan["targets"] else None
if not target:
return "Скажите, похоже на что: «похоже на Дюну».", plan
card, _ = _get("/search", {"q": target})
items = (card or {}).get("items") or []
film = next((i for i in items if i.get("kind") in ("фильм", "книга")), None)
if not film:
return "Не нашёл «" + target + "» в графе.", plan
data, err = _get("/similar", {"id": film["id"]})
if err or not data:
return "Похожего нет.", plan
lines = ["**Похоже на " + str(film.get("title")) + "**", ""]
for s in (data.get("similar") or [])[:8]:
lines.append("• " + str(s.get("title")) + " — общих: " + str(s.get("shared")))
return "\n".join(lines), plan
if intent == "compare":
targets = plan["targets"]
if len(targets) < 2:
return "Для сравнения назовите два объекта в кавычках: «Дюна» и «Дюна».", plan
data, err = _get("/compare", {"book": targets[0], "film": targets[1]})
if err or not data:
return "Не нашёл пару для сравнения (нужны книга и фильм).", plan
b, f = data["book"]["title"], data["film"]["title"]
lines = ["**" + b + "** и **" + f + "**", ""]
lines.append("• Связаны экранизацией: " + ("да" if data.get("linked") else "нет"))
if data.get("common_genres"):
lines.append("• Общие жанры: " + ", ".join(data["common_genres"]))
if data.get("only_book_genres"):
lines.append("• Только в книге: " + ", ".join(data["only_book_genres"]))
if data.get("only_film_genres"):
lines.append("• Только в фильме: " + ", ".join(data["only_film_genres"]))
if data.get("authors"):
lines.append("• Автор: " + ", ".join(data["authors"]))
return "\n".join(lines), plan
return "Не понял запрос.", plan