1273 lines
56 KiB
Python
1273 lines
56 KiB
Python
"""
|
||
Telegram AI Chatbot — Multi-persona, owner-protected, semantic memory
|
||
Powered by Groq API + PostgreSQL 16 + pgvector + Ollama embeddings
|
||
|
||
Config files:
|
||
.env — persona, bot name, trigger, rules (different per deployment)
|
||
.env_credentials — secret keys, DB and Ollama credentials
|
||
"""
|
||
|
||
import os
|
||
import re
|
||
import json
|
||
import random
|
||
import logging
|
||
import asyncio
|
||
import aiohttp
|
||
from urllib.parse import quote_plus
|
||
import datetime
|
||
import zoneinfo
|
||
import traceback
|
||
from functools import wraps
|
||
|
||
from dotenv import load_dotenv
|
||
|
||
load_dotenv(".env_credentials")
|
||
load_dotenv(".env")
|
||
|
||
import psycopg2
|
||
from psycopg2.extras import RealDictCursor
|
||
from psycopg2 import pool as pg_pool
|
||
|
||
from telegram import Update
|
||
from telegram.ext import (
|
||
Application, CommandHandler, MessageHandler,
|
||
filters, ContextTypes
|
||
)
|
||
from groq import Groq
|
||
try:
|
||
from openai import OpenAI
|
||
except ImportError:
|
||
OpenAI = None
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# CONFIG
|
||
# ══════════════════════════════════════════════
|
||
|
||
# ── Credentials (.env_credentials) ────────────
|
||
TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
|
||
GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
|
||
OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
|
||
LLM_PROVIDER = os.getenv("LLM_PROVIDER", "groq")
|
||
GROQ_MODEL = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
|
||
OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "deepseek/deepseek-chat-v3-0324")
|
||
|
||
PG_CONFIG = {
|
||
"host": os.getenv("PG_HOST", "localhost"),
|
||
"port": int(os.getenv("PG_PORT", "5432")),
|
||
"dbname": os.getenv("PG_DB", "manel_bot"),
|
||
"user": os.getenv("PG_USER", "postgres"),
|
||
"password": os.getenv("PG_PASSWORD", ""),
|
||
}
|
||
|
||
OWNER_ID = int(os.getenv("OWNER_TELEGRAM_ID", "0"))
|
||
|
||
# NewsData.io
|
||
NEWSDATA_API_KEY = os.getenv("NEWSDATA_API_KEY", "")
|
||
BRAVE_API_KEY = os.getenv("BRAVE_API_KEY", "") # real web search; DDG fallback if unset
|
||
|
||
# Ollama endpoint and embedding model
|
||
OLLAMA_URL = os.getenv("OLLAMA_URL", "http://localhost:11434")
|
||
EMBED_MODEL = os.getenv("EMBED_MODEL", "nomic-embed-text-v2-moe")
|
||
# nomic-embed-text-v2-moe output dimension — update if you switch models
|
||
EMBED_DIM = int(os.getenv("EMBED_DIM", "768"))
|
||
# How many semantically similar results to return per search_memory call
|
||
VECTOR_TOP_K = int(os.getenv("VECTOR_TOP_K", "8"))
|
||
# Minimum cosine similarity for search_memory results (nomic-embed scores
|
||
# for unrelated text usually sit around 0.3-0.5, so 0.45 is a sane floor)
|
||
MEM_SIM_THRESHOLD = float(os.getenv("MEM_SIM_THRESHOLD", "0.45"))
|
||
|
||
# ── Persona (.env) ─────────────────────────────
|
||
BOT_NAME = os.getenv("BOT_NAME", "Manel")
|
||
BOT_TRIGGER = os.getenv("BOT_TRIGGER", "manel")
|
||
BOT_MAX_CONTEXT = int(os.getenv("BOT_MAX_CONTEXT", "40"))
|
||
BOT_HISTORY_SAVE = int(os.getenv("BOT_HISTORY_SAVE", "500"))
|
||
|
||
BOT_ROLE = os.getenv("BOT_ROLE", "")
|
||
BOT_RULES = os.getenv("BOT_RULES", "")
|
||
BOT_TOOL_RULES = os.getenv("BOT_TOOL_RULES", "")
|
||
BOT_MEMORY_RULES = os.getenv("BOT_MEMORY_RULES", "")
|
||
BOT_EXAMPLES = os.getenv("BOT_EXAMPLES", "")
|
||
BOT_TIMEZONE = os.getenv("BOT_TIMEZONE", "Europe/Lisbon") # home timezone for date/time display
|
||
|
||
# ─────────────────────────────────────────────
|
||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
|
||
# httpx logs every Telegram API URL at INFO — including the bot token.
|
||
# Keep it quiet so tokens never land in logfiles.
|
||
logging.getLogger("httpx").setLevel(logging.WARNING)
|
||
log = logging.getLogger(__name__)
|
||
|
||
if LLM_PROVIDER == "openrouter":
|
||
if OpenAI is None:
|
||
raise ImportError("openai package not installed. Run: pip install openai")
|
||
llm_client = OpenAI(
|
||
api_key=OPENROUTER_API_KEY,
|
||
base_url="https://openrouter.ai/api/v1",
|
||
default_headers={"HTTP-Referer": "https://github.com/manel-bot"}
|
||
)
|
||
LLM_MODEL = OPENROUTER_MODEL
|
||
else:
|
||
llm_client = Groq(api_key=GROQ_API_KEY)
|
||
LLM_MODEL = GROQ_MODEL
|
||
pg_pool_conn: pg_pool.ThreadedConnectionPool | None = None
|
||
|
||
# Keep references to fire-and-forget tasks so they aren't garbage-collected
|
||
_bg_tasks: set = set()
|
||
|
||
def fire_and_forget(coro):
|
||
"""Schedule a coroutine in the background without awaiting it."""
|
||
task = asyncio.create_task(coro)
|
||
_bg_tasks.add(task)
|
||
task.add_done_callback(_bg_tasks.discard)
|
||
|
||
|
||
async def llm_create(**kwargs):
|
||
"""Run the (synchronous) LLM client call in a worker thread so the
|
||
Telegram event loop is never blocked while waiting on the API."""
|
||
return await asyncio.to_thread(lambda: llm_client.chat.completions.create(**kwargs))
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# SYSTEM PROMPT BUILDER
|
||
# ══════════════════════════════════════════════
|
||
def build_system_prompt(user_first_name: str, memories: list[str]) -> str:
|
||
def env_to_bullets(raw: str) -> str:
|
||
return "\n".join("- " + l.strip() for l in raw.splitlines() if l.strip())
|
||
|
||
memory_block = ""
|
||
if memories:
|
||
mem_lines = "\n".join("- " + m for m in memories)
|
||
memory_block = "\n\n[LONG-TERM MEMORY about users in this group]\n" + mem_lines
|
||
|
||
sections = []
|
||
if BOT_ROLE: sections.append("# Role\n" + BOT_ROLE)
|
||
if BOT_RULES: sections.append("# Rules\n" + env_to_bullets(BOT_RULES))
|
||
if BOT_TOOL_RULES: sections.append("# Tool Selection Strategy\n"+ env_to_bullets(BOT_TOOL_RULES))
|
||
if BOT_MEMORY_RULES: sections.append("# Memory Rules\n" + env_to_bullets(BOT_MEMORY_RULES))
|
||
if BOT_EXAMPLES: sections.append("# Examples\n" + BOT_EXAMPLES)
|
||
|
||
try:
|
||
home_tz = zoneinfo.ZoneInfo(BOT_TIMEZONE)
|
||
except Exception:
|
||
home_tz = datetime.timezone.utc
|
||
now_home = datetime.datetime.now(datetime.timezone.utc).astimezone(home_tz)
|
||
date_str = now_home.strftime("%A, %d %B %Y")
|
||
time_str = now_home.strftime("%H:%M")
|
||
|
||
time_block = (
|
||
f"Today is: {date_str}\n"
|
||
f"Current time ({BOT_TIMEZONE}): {time_str}\n"
|
||
f"For other timezones, use the web_search tool.\n"
|
||
f"IMPORTANT — your training data predates today. For sports results, "
|
||
f"competitions, news or any current events: (1) ALWAYS include the year "
|
||
f"{now_home.year} in your search query — e.g. 'mundial {now_home.year}', "
|
||
f"never a different year; (2) base your answer ONLY on the search results, "
|
||
f"never on what you remember about similar past events; (3) if the results "
|
||
f"don't contain the answer, say you don't know — do not fill gaps from memory."
|
||
)
|
||
|
||
sections.append("# Current Date and Time\n" + time_block)
|
||
|
||
sections.append(
|
||
"# Current User\n"
|
||
"The user who mentioned you is: " + user_first_name
|
||
+ memory_block
|
||
)
|
||
return "\n\n".join(sections)
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# OLLAMA EMBEDDINGS
|
||
# ══════════════════════════════════════════════
|
||
async def get_embedding(text: str) -> list[float] | None:
|
||
"""Call local Ollama to embed text. Returns list of floats or None on error."""
|
||
url = OLLAMA_URL.rstrip("/") + "/api/embed"
|
||
payload = {"model": EMBED_MODEL, "input": text}
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.post(url, json=payload, timeout=aiohttp.ClientTimeout(total=10)) as resp:
|
||
if resp.status != 200:
|
||
log.warning(f"Ollama embed HTTP {resp.status}: {await resp.text()}")
|
||
return None
|
||
data = await resp.json()
|
||
# Ollama /api/embed returns {"embeddings": [[...]]}
|
||
embeddings = data.get("embeddings")
|
||
if embeddings and len(embeddings) > 0:
|
||
return embeddings[0]
|
||
log.warning(f"Unexpected Ollama response: {data}")
|
||
return None
|
||
except Exception as e:
|
||
log.error(f"Ollama embedding error: {e}")
|
||
return None
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# DATABASE — PostgreSQL 16 + pgvector
|
||
# ══════════════════════════════════════════════
|
||
def init_db():
|
||
global pg_pool_conn
|
||
pg_pool_conn = pg_pool.ThreadedConnectionPool(1, 10, **PG_CONFIG)
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
# Enable pgvector extension
|
||
cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
|
||
|
||
cur.execute("""
|
||
CREATE TABLE IF NOT EXISTS users (
|
||
user_id TEXT PRIMARY KEY,
|
||
username TEXT,
|
||
full_name TEXT,
|
||
first_seen TIMESTAMPTZ DEFAULT NOW()
|
||
);
|
||
""")
|
||
|
||
cur.execute("""
|
||
CREATE TABLE IF NOT EXISTS memories (
|
||
id SERIAL PRIMARY KEY,
|
||
bot_name TEXT NOT NULL DEFAULT 'default',
|
||
user_id TEXT NOT NULL,
|
||
memory TEXT NOT NULL,
|
||
created TIMESTAMPTZ DEFAULT NOW(),
|
||
FOREIGN KEY (user_id) REFERENCES users(user_id) ON DELETE CASCADE
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_memories_bot_user
|
||
ON memories(bot_name, user_id);
|
||
""")
|
||
|
||
# History table with vector column for semantic search
|
||
cur.execute(f"""
|
||
CREATE TABLE IF NOT EXISTS history (
|
||
id SERIAL PRIMARY KEY,
|
||
bot_name TEXT NOT NULL DEFAULT 'default',
|
||
chat_id TEXT NOT NULL,
|
||
user_id TEXT,
|
||
username TEXT,
|
||
role TEXT NOT NULL,
|
||
content TEXT NOT NULL,
|
||
embedding vector({EMBED_DIM}),
|
||
created TIMESTAMPTZ DEFAULT NOW()
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_history_bot_chat
|
||
ON history(bot_name, chat_id, created DESC);
|
||
""")
|
||
|
||
# IVFFlat index for fast vector search (built lazily once rows exist)
|
||
# We create it only if it doesn't exist yet
|
||
cur.execute("""
|
||
SELECT 1 FROM pg_indexes
|
||
WHERE tablename = 'history' AND indexname = 'idx_history_embedding';
|
||
""")
|
||
if not cur.fetchone():
|
||
# Only create after enough rows accumulate — skip silently for now
|
||
# The bot will still work via sequential scan until you run:
|
||
# CREATE INDEX idx_history_embedding ON history
|
||
# USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
|
||
log.info("Vector index not yet created — will use seq scan until you create it manually.")
|
||
|
||
con.commit()
|
||
log.info(f"PostgreSQL + pgvector ready. Bot={BOT_NAME} dim={EMBED_DIM}")
|
||
|
||
|
||
class get_db:
|
||
def __enter__(self):
|
||
self.con = pg_pool_conn.getconn()
|
||
return self.con
|
||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||
try:
|
||
if exc_type is not None:
|
||
# A failed statement leaves the connection in an aborted
|
||
# transaction — roll back before returning it to the pool.
|
||
try:
|
||
self.con.rollback()
|
||
except Exception:
|
||
pass
|
||
finally:
|
||
pg_pool_conn.putconn(self.con)
|
||
return False # don't suppress exceptions
|
||
|
||
|
||
# ── Users ──────────────────────────────────────
|
||
def upsert_user(user_id: str, username: str, full_name: str):
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute("""
|
||
INSERT INTO users (user_id, username, full_name)
|
||
VALUES (%s, %s, %s)
|
||
ON CONFLICT (user_id) DO UPDATE
|
||
SET username = EXCLUDED.username,
|
||
full_name = EXCLUDED.full_name
|
||
""", (user_id, username, full_name))
|
||
con.commit()
|
||
|
||
|
||
def user_exists(user_id: str) -> bool:
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute("SELECT 1 FROM users WHERE user_id = %s", (user_id,))
|
||
return cur.fetchone() is not None
|
||
|
||
|
||
# ── History ────────────────────────────────────
|
||
def store_message_sync(chat_id: str, user_id: str | None, username: str,
|
||
role: str, content: str, embedding: list[float] | None):
|
||
"""Synchronous DB write — called from async context via asyncio.to_thread."""
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute("""
|
||
INSERT INTO history
|
||
(bot_name, chat_id, user_id, username, role, content, embedding)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s)
|
||
""", (BOT_NAME, chat_id, user_id, username, role, content, embedding))
|
||
|
||
# Trim oldest beyond BOT_HISTORY_SAVE.
|
||
# Probabilistic (~1 in 50 inserts): the subquery sorts the whole
|
||
# chat history, which is too expensive to run on every message.
|
||
# Ordered by id — created has second resolution and ties are
|
||
# nondeterministic.
|
||
if random.random() < 0.02:
|
||
cur.execute("""
|
||
DELETE FROM history
|
||
WHERE bot_name = %s AND chat_id = %s AND id NOT IN (
|
||
SELECT id FROM history
|
||
WHERE bot_name = %s AND chat_id = %s
|
||
ORDER BY id DESC LIMIT %s
|
||
)
|
||
""", (BOT_NAME, chat_id, BOT_NAME, chat_id, BOT_HISTORY_SAVE))
|
||
con.commit()
|
||
|
||
|
||
async def store_message(chat_id: str, user_id: str | None, username: str,
|
||
role: str, content: str):
|
||
"""Embed the message then write to DB. Non-blocking — runs embedding + DB in thread."""
|
||
embedding = await get_embedding(content)
|
||
if embedding is None:
|
||
log.warning("Storing message without embedding (Ollama unavailable).")
|
||
await asyncio.to_thread(store_message_sync, chat_id, user_id, username, role, content, embedding)
|
||
|
||
|
||
def get_group_context(chat_id: str, limit: int = BOT_MAX_CONTEXT) -> list[dict]:
|
||
"""Fetch most recent messages for LLM context window."""
|
||
with get_db() as con:
|
||
with con.cursor(cursor_factory=RealDictCursor) as cur:
|
||
cur.execute("""
|
||
SELECT role, username, content, created
|
||
FROM history
|
||
WHERE bot_name = %s AND chat_id = %s
|
||
ORDER BY id DESC LIMIT %s
|
||
""", (BOT_NAME, chat_id, limit))
|
||
rows = cur.fetchall()
|
||
return list(reversed(rows))
|
||
|
||
|
||
def get_history_for_llm(chat_id: str) -> list[dict]:
|
||
rows = get_group_context(chat_id, BOT_MAX_CONTEXT)
|
||
result = []
|
||
for r in rows:
|
||
if r["role"] == "user":
|
||
# Label each user message with their name so the LLM knows who said what
|
||
prefix = f"[{r['username']}] " if r["username"] else ""
|
||
result.append({"role": "user", "content": prefix + r["content"]})
|
||
else:
|
||
# Assistant messages: no prefix — prevents model from echoing "[Manel]" in replies
|
||
result.append({"role": "assistant", "content": r["content"]})
|
||
return result
|
||
|
||
|
||
def vector_search_sync(chat_id: str, query_embedding: list[float], top_k: int) -> list[dict]:
|
||
"""Cosine similarity search against history embeddings."""
|
||
with get_db() as con:
|
||
with con.cursor(cursor_factory=RealDictCursor) as cur:
|
||
cur.execute("""
|
||
SELECT username, content, created,
|
||
1 - (embedding <=> %s::vector) AS similarity
|
||
FROM history
|
||
WHERE bot_name = %s
|
||
AND chat_id = %s
|
||
AND embedding IS NOT NULL
|
||
ORDER BY embedding <=> %s::vector
|
||
LIMIT %s
|
||
""", (query_embedding, BOT_NAME, chat_id, query_embedding, top_k))
|
||
return cur.fetchall()
|
||
|
||
|
||
def clear_history(chat_id: str):
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute(
|
||
"DELETE FROM history WHERE bot_name = %s AND chat_id = %s",
|
||
(BOT_NAME, chat_id)
|
||
)
|
||
con.commit()
|
||
|
||
|
||
# ── Memories ───────────────────────────────────
|
||
def add_memory(user_id: str, memory: str):
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute(
|
||
"INSERT INTO memories (bot_name, user_id, memory) VALUES (%s, %s, %s)",
|
||
(BOT_NAME, user_id, memory)
|
||
)
|
||
con.commit()
|
||
|
||
|
||
def get_memories(user_id: str) -> list[str]:
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT memory FROM memories
|
||
WHERE bot_name = %s AND user_id = %s
|
||
ORDER BY created DESC LIMIT 50
|
||
""", (BOT_NAME, user_id))
|
||
return [r[0] for r in cur.fetchall()]
|
||
|
||
|
||
def get_all_memories_indexed(user_id: str) -> list[tuple]:
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute("""
|
||
SELECT id, memory FROM memories
|
||
WHERE bot_name = %s AND user_id = %s
|
||
ORDER BY created DESC LIMIT 50
|
||
""", (BOT_NAME, user_id))
|
||
return cur.fetchall()
|
||
|
||
|
||
def delete_memory_by_id(memory_id: int):
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute(
|
||
"DELETE FROM memories WHERE id = %s AND bot_name = %s",
|
||
(memory_id, BOT_NAME)
|
||
)
|
||
con.commit()
|
||
|
||
|
||
def clear_memories(user_id: str):
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute(
|
||
"DELETE FROM memories WHERE bot_name = %s AND user_id = %s",
|
||
(BOT_NAME, user_id)
|
||
)
|
||
con.commit()
|
||
|
||
|
||
def clear_all_memories():
|
||
with get_db() as con:
|
||
with con.cursor() as cur:
|
||
cur.execute("DELETE FROM memories WHERE bot_name = %s", (BOT_NAME,))
|
||
con.commit()
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# OWNER GUARD
|
||
# ══════════════════════════════════════════════
|
||
def owner_only(func):
|
||
@wraps(func)
|
||
async def wrapper(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
if update.effective_user.id != OWNER_ID:
|
||
log.warning(f"Blocked admin command from user_id={update.effective_user.id}")
|
||
await update.message.reply_text("⛔ Não tens permissão para usar este comando.")
|
||
return
|
||
return await func(update, ctx)
|
||
return wrapper
|
||
|
||
def is_owner(update: Update) -> bool:
|
||
return update.effective_user.id == OWNER_ID
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# WEB SEARCH — DuckDuckGo + Open-Meteo weather
|
||
# ══════════════════════════════════════════════
|
||
WEATHER_KEYWORDS = [
|
||
"tempo", "weather", "temperatura", "chuva", "chover", "sol", "vento", "neve",
|
||
"frio", "calor", "forecast", "previsão", "graus", "humidade", "nublado",
|
||
"trovoada", "granizo", "nevoeiro", "céu", "guarda-chuva",
|
||
"mínima", "máxima", "minima", "maxima", "sensação", "precipitação"
|
||
]
|
||
|
||
# Keywords that require a web search for current time in other timezones
|
||
TIMEZONE_KEYWORDS = [
|
||
"que horas são", "que horas", "horas são", "hora é", "que hora",
|
||
"what time", "horas na", "horas em", "horas no", "horas nos",
|
||
"horas são na", "horas são em", "horas aí", "horas lá",
|
||
"fuso horário", "timezone", "time zone"
|
||
]
|
||
|
||
# Location words that combined with recent time context suggest a timezone followup
|
||
TIMEZONE_PLACES = [
|
||
"islândia", "iceland", "finlândia", "finland", "portugal", "espanha",
|
||
"spain", "frança", "france", "alemanha", "germany", "reino unido",
|
||
"uk", "brasil", "brazil", "estados unidos", "usa", "london", "paris",
|
||
"lisboa", "madrid", "berlim", "berlin", "reykjavik"
|
||
]
|
||
|
||
def _kw_match(text: str, keywords) -> bool:
|
||
"""Whole-word/phrase match. Plain `kw in text` gives false positives:
|
||
'sol' matches 'consola', 'vento' matches 'invento', etc. — and those
|
||
false positives *force* a web_search tool call downstream."""
|
||
q = text.lower()
|
||
return any(
|
||
re.search(r"(?<!\w)" + re.escape(kw) + r"(?!\w)", q)
|
||
for kw in keywords
|
||
)
|
||
|
||
|
||
def is_timezone_query(query: str) -> bool:
|
||
if _kw_match(query, TIMEZONE_KEYWORDS):
|
||
return True
|
||
# Short followup like "e na Islândia?" — place name + no other topic
|
||
if _kw_match(query, TIMEZONE_PLACES):
|
||
words = query.lower().split()
|
||
if len(words) <= 6 and not _kw_match(query, WEATHER_KEYWORDS):
|
||
return True
|
||
return False
|
||
|
||
NEWS_KEYWORDS = [
|
||
"notícias", "noticias", "noticia", "notícia", "news", "últimas", "ultimas",
|
||
"hoje no jornal", "manchetes", "atualidade", "atualidades", "pesquisa",
|
||
"pesquisar", "procura na internet", "procurar na internet", "pesquisa na internet",
|
||
"o que aconteceu", "o que se passa", "novidades"
|
||
]
|
||
|
||
def is_news_query(query: str) -> bool:
|
||
return _kw_match(query, NEWS_KEYWORDS)
|
||
|
||
# WMO weather code → Portuguese description
|
||
WMO_CODES = {
|
||
0: "céu limpo", 1: "principalmente limpo", 2: "parcialmente nublado", 3: "nublado",
|
||
45: "nevoeiro", 48: "nevoeiro com geada",
|
||
51: "chuviscos fracos", 53: "chuviscos moderados", 55: "chuviscos densos",
|
||
61: "chuva fraca", 63: "chuva moderada", 65: "chuva forte",
|
||
71: "neve fraca", 73: "neve moderada", 75: "neve forte",
|
||
77: "grãos de neve", 80: "aguaceiros fracos", 81: "aguaceiros moderados", 82: "aguaceiros violentos",
|
||
85: "aguaceiros de neve fracos", 86: "aguaceiros de neve fortes",
|
||
95: "trovoada", 96: "trovoada com granizo", 99: "trovoada com granizo forte"
|
||
}
|
||
|
||
def is_weather_query(query: str) -> bool:
|
||
return _kw_match(query, WEATHER_KEYWORDS)
|
||
|
||
|
||
# Nominatim allows max 1 req/s — cache geocode results so repeated
|
||
# questions about the same place don't hit it again.
|
||
_geo_cache: dict[str, tuple[float, float, str]] = {}
|
||
|
||
|
||
async def weather_search(query: str) -> str | None:
|
||
"""Geocode location then call Open-Meteo for current + forecast. No API key needed."""
|
||
|
||
# Extract location using word-boundary replacement
|
||
stop_words = (
|
||
WEATHER_KEYWORDS
|
||
+ [BOT_TRIGGER, "hoje", "amanhã", "amanha", "agora", "atual", "atualmente",
|
||
"esta", "semana", "preciso", "precisas", "precisa",
|
||
"qual", "como", "está", "vai", "vais", "vou",
|
||
"janeiro", "fevereiro", "março", "marco", "abril", "maio", "junho",
|
||
"julho", "agosto", "setembro", "outubro", "novembro", "dezembro",
|
||
# the model frequently writes tool queries in English
|
||
"january", "february", "march", "april", "may", "june", "july",
|
||
"august", "september", "october", "november", "december",
|
||
"today", "tomorrow", "tonight", "now", "current", "currently",
|
||
"this", "week", "weekend", "what", "whats", "is", "the", "in",
|
||
"at", "for", "of", "and",
|
||
"o", "a", "os", "as", "em", "de", "do", "da", "dos", "das",
|
||
"para", "por", "com", "sem", "?", "!"]
|
||
)
|
||
location = query.lower()
|
||
for sw in sorted(stop_words, key=len, reverse=True):
|
||
location = re.sub(r"\b" + re.escape(sw) + r"\b", " ", location)
|
||
# Drop stray numbers (day/year the model puts in search queries) —
|
||
# "faro 17 2026" geocodes to nothing and we'd lose the real weather data.
|
||
location = " ".join(w for w in location.split() if not w.isdigit()).strip()
|
||
|
||
if not location:
|
||
return None # No location — let LLM answer from context
|
||
|
||
try:
|
||
# Step 1: Geocode with Nominatim (cached — usage policy is 1 req/s)
|
||
if location in _geo_cache:
|
||
lat, lon, name = _geo_cache[location]
|
||
else:
|
||
geo_url = "https://nominatim.openstreetmap.org/search"
|
||
geo_params = {"q": location, "format": "json", "limit": 1}
|
||
headers = {"User-Agent": "ManelBot/1.0"}
|
||
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(geo_url, params=geo_params, headers=headers,
|
||
timeout=aiohttp.ClientTimeout(total=8)) as r:
|
||
geo = await r.json()
|
||
|
||
if not geo:
|
||
# Signal "couldn't geocode" — caller falls back to a normal
|
||
# web search instead of telling the model to rephrase forever.
|
||
log.warning(f"Geocode miss for extracted location: '{location}'")
|
||
return None
|
||
|
||
lat = float(geo[0]["lat"])
|
||
lon = float(geo[0]["lon"])
|
||
name = geo[0]["display_name"].split(",")[0]
|
||
_geo_cache[location] = (lat, lon, name)
|
||
|
||
# Step 2: Open-Meteo current + hourly forecast
|
||
om_url = "https://api.open-meteo.com/v1/forecast"
|
||
om_params = (
|
||
f"latitude={lat}&longitude={lon}"
|
||
f"¤t=temperature_2m,apparent_temperature,relative_humidity_2m,"
|
||
f"precipitation,weather_code,wind_speed_10m,wind_gusts_10m"
|
||
f"&hourly=temperature_2m,precipitation_probability,weather_code,wind_gusts_10m"
|
||
f"&forecast_days=1&timezone=auto&models=ecmwf_ifs025"
|
||
)
|
||
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(f"{om_url}?{om_params}",
|
||
timeout=aiohttp.ClientTimeout(total=8)) as r:
|
||
if r.status != 200:
|
||
return f"Erro ao obter tempo (HTTP {r.status})."
|
||
data = await r.json()
|
||
|
||
cur = data["current"]
|
||
temp = cur["temperature_2m"]
|
||
feels = cur["apparent_temperature"]
|
||
humidity = cur["relative_humidity_2m"]
|
||
wind = cur["wind_speed_10m"]
|
||
gusts = cur["wind_gusts_10m"]
|
||
wcode = cur["weather_code"]
|
||
desc = WMO_CODES.get(wcode, f"código {wcode}")
|
||
|
||
result = (
|
||
f"🌍 {name}\n"
|
||
f"🌡️ {temp:.0f}°C (sensação {feels:.0f}°C)\n"
|
||
f"🌤️ {desc.capitalize()}\n"
|
||
f"💧 Humidade: {humidity}%\n"
|
||
f"💨 Vento: {wind:.0f} km/h (rajadas até {gusts:.0f} km/h)"
|
||
)
|
||
|
||
# Next few hours
|
||
hours = data["hourly"]["time"]
|
||
temps = data["hourly"]["temperature_2m"]
|
||
probs = data["hourly"]["precipitation_probability"]
|
||
wcodes = data["hourly"]["weather_code"]
|
||
|
||
# Use UTC offset from Open-Meteo response to get correct local time.
|
||
# Compare full timestamps — comparing only hour-of-day breaks near
|
||
# midnight (at 23:00 there would be no "upcoming" hours at all).
|
||
utc_offset = data.get("utc_offset_seconds", 0)
|
||
now_local = (datetime.datetime.now(datetime.timezone.utc) +
|
||
datetime.timedelta(seconds=utc_offset)).replace(tzinfo=None)
|
||
upcoming = [(h, t, p, w) for h, t, p, w in zip(hours, temps, probs, wcodes)
|
||
if datetime.datetime.fromisoformat(h) > now_local][:4]
|
||
|
||
if upcoming:
|
||
result += "\n\n📅 Próximas horas:"
|
||
for h, t, p, w in upcoming:
|
||
d = WMO_CODES.get(w, "")
|
||
result += f"\n {h[11:16]} — {t:.0f}°C, {p}% chuva, {d}"
|
||
|
||
return result
|
||
|
||
except Exception as e:
|
||
log.warning(f"Open-Meteo error: {e}")
|
||
return "Serviço meteorológico indisponível agora."
|
||
|
||
|
||
async def web_search(query: str) -> str:
|
||
"""Route weather queries to Open-Meteo, everything else to DuckDuckGo."""
|
||
if is_weather_query(query):
|
||
result = await weather_search(query)
|
||
if result is not None:
|
||
return result
|
||
# Couldn't extract/geocode a location — fall through to a regular
|
||
# web search of the original query rather than dead-ending the model.
|
||
log.info("weather_search found no location — falling back to general search")
|
||
|
||
# Use NewsData.io for news queries, DuckDuckGo for everything else
|
||
if is_news_query(query) and NEWSDATA_API_KEY:
|
||
try:
|
||
# Detect if query is about Portugal specifically
|
||
pt_keywords = ["portugal", "nacional", "nacionais", "portuguesa", "português",
|
||
"porto", "lisboa", "governo", "assembleia", "república"]
|
||
is_pt = any(kw in query.lower() for kw in pt_keywords)
|
||
|
||
if is_pt:
|
||
# Portuguese national news — Portuguese language, Portugal only
|
||
params = {
|
||
"apikey": NEWSDATA_API_KEY,
|
||
"language": "pt",
|
||
"country": "pt",
|
||
"size": 6,
|
||
}
|
||
else:
|
||
# International news — English, no country filter, use query keywords
|
||
params = {
|
||
"apikey": NEWSDATA_API_KEY,
|
||
"language": "en",
|
||
"size": 6,
|
||
"q": query,
|
||
}
|
||
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get("https://newsdata.io/api/1/news",
|
||
params=params,
|
||
timeout=aiohttp.ClientTimeout(total=8)) as resp:
|
||
data = await resp.json()
|
||
|
||
if data.get("status") == "success" and data.get("results"):
|
||
lines = []
|
||
for art in data["results"][:5]:
|
||
title = art.get("title", "").strip()
|
||
source = art.get("source_name") or art.get("source_id", "")
|
||
source = source.strip() if source else ""
|
||
pubdate = art.get("pubDate", "")[:10]
|
||
if title:
|
||
lines.append(f"• {title}" + (f" ({source}, {pubdate})" if source else ""))
|
||
return "\n".join(lines) if lines else "Sem notícias encontradas."
|
||
return "Sem notícias encontradas."
|
||
except Exception as e:
|
||
log.warning(f"NewsData.io error: {e}")
|
||
|
||
# Brave Search — real web results (titles + snippets), best for current
|
||
# events, sports, prices. Free tier: ~2000 queries/month.
|
||
if BRAVE_API_KEY:
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(
|
||
"https://api.search.brave.com/res/v1/web/search",
|
||
params={"q": query, "count": 5},
|
||
headers={"X-Subscription-Token": BRAVE_API_KEY,
|
||
"Accept": "application/json"},
|
||
timeout=aiohttp.ClientTimeout(total=8),
|
||
) as resp:
|
||
if resp.status == 429:
|
||
log.warning("Brave API rate/quota limit hit — falling back to DDG")
|
||
raise RuntimeError("brave quota")
|
||
resp.raise_for_status()
|
||
data = await resp.json()
|
||
|
||
lines = []
|
||
for r in (data.get("web", {}).get("results") or [])[:5]:
|
||
title = (r.get("title") or "").strip()
|
||
desc = re.sub(r"<[^>]+>", "", r.get("description") or "").strip()
|
||
url_ = r.get("url", "")
|
||
age = r.get("age", "")
|
||
if title:
|
||
lines.append(f"• {title}" + (f" ({age})" if age else "")
|
||
+ (f"\n {desc}" if desc else "")
|
||
+ (f"\n {url_}" if url_ else ""))
|
||
if lines:
|
||
return "\n".join(lines)
|
||
log.info("Brave returned no results — falling back to DDG")
|
||
except Exception as e:
|
||
log.warning(f"Brave search error: {e} — falling back to DDG")
|
||
|
||
# DuckDuckGo Instant Answer fallback (encyclopedic answers only)
|
||
url = f"https://api.duckduckgo.com/?q={quote_plus(query)}&format=json&no_redirect=1&no_html=1&skip_disambig=1"
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(url, timeout=aiohttp.ClientTimeout(total=8)) as resp:
|
||
data = await resp.json(content_type=None)
|
||
results = []
|
||
if data.get("AbstractText"):
|
||
results.append(data["AbstractText"])
|
||
if data.get("AbstractURL"):
|
||
results.append("Fonte: " + data["AbstractURL"])
|
||
for topic in data.get("RelatedTopics", [])[:4]:
|
||
if isinstance(topic, dict) and topic.get("Text"):
|
||
results.append("• " + topic["Text"])
|
||
return "\n".join(results) if results else "Sem resultados. Responderei com base no meu conhecimento."
|
||
except Exception as e:
|
||
log.warning(f"Web search error: {e}")
|
||
return "Pesquisa web indisponível agora."
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# TRIGGER CHECK
|
||
# ══════════════════════════════════════════════
|
||
# Some models (e.g. DeepSeek) occasionally emit their native tool-call
|
||
# markup as plain text instead of structured tool_calls — that must never
|
||
# be posted to the chat.
|
||
_MARKUP_PATTERNS = [
|
||
r"</?[｜|]DSML[｜|][^>]*>", # DeepSeek DSML tags: <｜DSML｜tool_calls> etc.
|
||
r"<[｜|][^<>]*[｜|]>", # generic <｜...｜> special tokens
|
||
r"</?tool_calls?[^>]*>", # <tool_call> style wrappers
|
||
r"</?function(?:_call)?[^>]*>",
|
||
]
|
||
|
||
def sanitize_reply(text: str) -> str:
|
||
"""Cut the reply at the first tool-markup tag. Any text after the model
|
||
starts 'calling a tool' in plain text is machinery, not an answer —
|
||
a pure-markup reply becomes empty and the caller falls back to '…'."""
|
||
if not text or "<" not in text:
|
||
return text
|
||
earliest = len(text)
|
||
for p in _MARKUP_PATTERNS:
|
||
m = re.search(p, text, flags=re.IGNORECASE)
|
||
if m:
|
||
earliest = min(earliest, m.start())
|
||
if earliest == len(text):
|
||
return text
|
||
log.warning("Model reply contained raw tool-call markup — truncated before it")
|
||
return text[:earliest].strip()
|
||
|
||
|
||
def is_mentioned(text: str) -> bool:
|
||
trig = re.escape(BOT_TRIGGER)
|
||
# 1) Whole-word match, any capitalization: "tabernas", "Tabernas,", "TABERNAS!"
|
||
# — but not inside other words ("tabernasca").
|
||
if re.search(r"(?<!\w)" + trig + r"(?!\w)", text, re.IGNORECASE):
|
||
return True
|
||
# 2) Telegram @username mentions: "@tabernas_bot", "@TabernasBot" —
|
||
# the trigger is glued to "_bot"/"bot" there, so rule 1 misses it.
|
||
return bool(re.search(r"@\w*" + trig + r"\w*", text, re.IGNORECASE))
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# GROQ — tool definitions
|
||
# ══════════════════════════════════════════════
|
||
TOOLS = [
|
||
{
|
||
"type": "function",
|
||
"function": {
|
||
"name": "web_search",
|
||
"description": "Search the web for current info: weather, news, prices, general questions.",
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"query": {"type": "string", "description": "The search query"}
|
||
},
|
||
"required": ["query"]
|
||
}
|
||
}
|
||
},
|
||
{
|
||
"type": "function",
|
||
"function": {
|
||
"name": "search_memory",
|
||
"description": (
|
||
"Semantic search through the full group chat history and long-term memories. "
|
||
"Use for past preferences, facts, or anything said more than a few messages ago. "
|
||
"Returns the most relevant past messages by meaning, not just keywords."
|
||
),
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"query": {
|
||
"type": "string",
|
||
"description": "Natural language description of what to look for"
|
||
}
|
||
},
|
||
"required": ["query"]
|
||
}
|
||
}
|
||
},
|
||
{
|
||
"type": "function",
|
||
"function": {
|
||
"name": "save_memory",
|
||
"description": "Save an important fact about a user for future conversations.",
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"user_id": {"type": "string", "description": "Telegram user_id of the person"},
|
||
"memory": {"type": "string", "description": "The fact to save"}
|
||
},
|
||
"required": ["user_id", "memory"]
|
||
}
|
||
}
|
||
}
|
||
]
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# GROQ — main chat function
|
||
# ══════════════════════════════════════════════
|
||
async def _nudge_final(messages: list) -> str:
|
||
"""One retry with an explicit plain-text instruction — used whenever the
|
||
model returns an empty (or markup-only) answer."""
|
||
messages.append({
|
||
"role": "user",
|
||
"content": ("[system] Responde AGORA em texto simples, em português, "
|
||
"com base na conversa acima. Sem chamadas de ferramentas. "
|
||
"Se não tiveres a informação, di-lo honestamente e com humor.")
|
||
})
|
||
r = await llm_create(
|
||
model=LLM_MODEL, messages=messages, max_tokens=2048, temperature=0.7
|
||
)
|
||
return sanitize_reply(r.choices[0].message.content or "")
|
||
|
||
|
||
async def chat_with_groq(chat_id: str, user_id: str, user_first_name: str, user_message: str) -> str:
|
||
# DB reads in a worker thread — never block the Telegram event loop
|
||
memories = await asyncio.to_thread(get_memories, user_id)
|
||
history = await asyncio.to_thread(get_history_for_llm, chat_id)
|
||
system = build_system_prompt(user_first_name, memories)
|
||
|
||
# NOTE: the triggering message was already stored by handle_message, so
|
||
# it is the last entry of `history` (with its [name] prefix). Do NOT
|
||
# append it again — that duplicated the current message in every prompt.
|
||
messages = [{"role": "system", "content": system}] + history
|
||
|
||
# Force web_search tool when weather, timezone or news keywords detected
|
||
if is_weather_query(user_message):
|
||
tool_choice = {"type": "function", "function": {"name": "web_search"}}
|
||
log.info("Forcing web_search for weather query")
|
||
elif is_timezone_query(user_message):
|
||
tool_choice = {"type": "function", "function": {"name": "web_search"}}
|
||
log.info("Forcing web_search for timezone query")
|
||
elif is_news_query(user_message):
|
||
tool_choice = {"type": "function", "function": {"name": "web_search"}}
|
||
log.info("Forcing web_search for news query")
|
||
# Inject intent into messages so model generates correct query
|
||
intl_keywords = ["internacionais", "internacional", "mundo", "world", "international"]
|
||
if any(kw in user_message.lower() for kw in intl_keywords):
|
||
# Prepend hint to system prompt instead of fake user message
|
||
messages[0]["content"] += "\n\nNEXT TOOL CALL: Search for INTERNATIONAL world news in English. Do NOT include Portugal in query."
|
||
else:
|
||
messages[0]["content"] += "\n\nNEXT TOOL CALL: Search for Portuguese national news. Use query: noticias portugal hoje."
|
||
else:
|
||
tool_choice = "auto"
|
||
forced = tool_choice != "auto"
|
||
|
||
response = await llm_create(
|
||
model=LLM_MODEL,
|
||
messages=messages,
|
||
tools=TOOLS,
|
||
tool_choice=tool_choice,
|
||
max_tokens=2048,
|
||
temperature=0.7,
|
||
)
|
||
|
||
msg = response.choices[0].message
|
||
tool_calls = msg.tool_calls or []
|
||
|
||
if not tool_calls:
|
||
reply = msg.content or ""
|
||
# Model was forced to call a tool but produced neither a tool call
|
||
# nor usable content.
|
||
if forced and (not reply.strip() or reply.strip() == "…"):
|
||
if is_weather_query(user_message):
|
||
log.info("Model skipped forced tool — calling weather_search directly")
|
||
weather_result = await weather_search(user_message)
|
||
if weather_result:
|
||
messages.append({"role": "user", "content": f"[weather data]\n{weather_result}\n\nAnswer the user naturally in Portuguese based on this data."})
|
||
r2 = await llm_create(
|
||
model=LLM_MODEL, messages=messages, max_tokens=2048, temperature=0.7
|
||
)
|
||
return sanitize_reply(r2.choices[0].message.content or "") or "…"
|
||
# Timezone/news (or weather with no direct result): retry once
|
||
# without forcing so the model can answer normally.
|
||
log.info("Model skipped forced tool — retrying with tool_choice=auto")
|
||
r2 = await llm_create(
|
||
model=LLM_MODEL, messages=messages, tools=TOOLS,
|
||
tool_choice="auto", max_tokens=2048, temperature=0.7,
|
||
)
|
||
m2 = r2.choices[0].message
|
||
if not (m2.tool_calls or []):
|
||
return sanitize_reply(m2.content or "") or "…"
|
||
msg, tool_calls = m2, m2.tool_calls
|
||
else:
|
||
reply = sanitize_reply(reply)
|
||
if not reply:
|
||
# No tools, no text — typically the model spent the whole
|
||
# token budget on reasoning. Nudge once for a plain answer.
|
||
log.warning(
|
||
f"Empty direct reply (finish_reason="
|
||
f"{response.choices[0].finish_reason}) — retrying with nudge"
|
||
)
|
||
reply = await _nudge_final(messages)
|
||
return reply or "…"
|
||
|
||
# ── Multi-round tool loop ─────────────────────────────────────────
|
||
# The model may need to chain tools (search the city, then search its
|
||
# weather). Previously the post-tool call passed no `tools`, so models
|
||
# wanting a second search emitted raw tool markup as text.
|
||
MAX_TOOL_ROUNDS = 3
|
||
rounds = 0
|
||
seen_calls: dict = {} # (fn, normalized args) -> previous result
|
||
while tool_calls:
|
||
rounds += 1
|
||
messages.append({
|
||
"role": "assistant",
|
||
"content": msg.content or "",
|
||
"tool_calls": [
|
||
{"id": tc.id, "type": "function",
|
||
"function": {"name": tc.function.name, "arguments": tc.function.arguments}}
|
||
for tc in tool_calls
|
||
]
|
||
})
|
||
|
||
for tc in tool_calls:
|
||
fn = tc.function.name
|
||
# Key for dedupe — computed outside the try so it always exists,
|
||
# even when the arguments fail to parse.
|
||
call_key = (fn, (tc.function.arguments or "").strip().lower())
|
||
# Each tool runs in its own try/except: one bad tool call (bad JSON
|
||
# args, FK violation, network error) must not kill the whole reply.
|
||
try:
|
||
args = json.loads(tc.function.arguments)
|
||
log.info(f"Tool: {fn}({args})")
|
||
|
||
# Dedupe: the model sometimes re-issues near-identical searches
|
||
# and burns the whole round budget. Return the cached result
|
||
# with an explicit instruction to answer.
|
||
if call_key in seen_calls:
|
||
log.info("Duplicate tool call detected — returning cached result")
|
||
result = ("[REPEATED SEARCH — same result as before]\n"
|
||
+ seen_calls[call_key]
|
||
+ "\n\nDo NOT search again. Answer the user now "
|
||
"in Portuguese using the information above. If the "
|
||
"information is insufficient, say so honestly.")
|
||
messages.append({"role": "tool", "content": result, "tool_call_id": tc.id})
|
||
continue
|
||
|
||
if fn == "web_search":
|
||
result = await web_search(args["query"])
|
||
# Stamp results with today's date — reminds the model at
|
||
# the moment of answering that these are current, and its
|
||
# own memory of similar past events is not.
|
||
today = datetime.datetime.now().strftime("%d/%m/%Y")
|
||
result = (f"[Search results — today is {today}. Answer from "
|
||
f"these results, not from memory.]\n{result}")
|
||
|
||
elif fn == "search_memory":
|
||
query = args["query"]
|
||
found = []
|
||
|
||
# ── 1. Semantic search over group history ──────────────
|
||
query_emb = await get_embedding(query)
|
||
if query_emb:
|
||
rows = await asyncio.to_thread(
|
||
vector_search_sync, chat_id, query_emb, VECTOR_TOP_K
|
||
)
|
||
for row in rows:
|
||
sim = float(row["similarity"])
|
||
if sim < MEM_SIM_THRESHOLD: # skip low similarity
|
||
continue
|
||
ts = row["created"].strftime("%Y-%m-%d %H:%M") if row.get("created") else "?"
|
||
found.append(
|
||
f"[{ts}] {row.get('username', '?')} (sim={sim:.2f}): {row['content']}"
|
||
)
|
||
else:
|
||
log.warning("search_memory: no embedding — skipping vector search")
|
||
|
||
# ── 2. Always include saved long-term memories ─────────
|
||
for mem in await asyncio.to_thread(get_memories, user_id):
|
||
found.append(f"[memory] {mem}")
|
||
|
||
if found:
|
||
result = "\n".join(found)
|
||
else:
|
||
result = "Nothing relevant found in memory."
|
||
|
||
elif fn == "save_memory":
|
||
# Only accept a target user_id the bot has actually seen;
|
||
# a hallucinated ID would violate the FK on memories.user_id.
|
||
# Default to the person speaking.
|
||
target_uid = str(args.get("user_id") or user_id)
|
||
if target_uid != user_id and not await asyncio.to_thread(user_exists, target_uid):
|
||
log.warning(f"save_memory: unknown user_id {target_uid}, saving under caller")
|
||
target_uid = user_id
|
||
await asyncio.to_thread(add_memory, target_uid, args["memory"])
|
||
result = f"Memory saved: {args['memory']}"
|
||
|
||
else:
|
||
result = "Unknown tool."
|
||
|
||
except Exception as e:
|
||
log.error(f"Tool {fn} failed: {e}\n{traceback.format_exc()}")
|
||
result = f"Tool error: {e}"
|
||
|
||
seen_calls[call_key] = result
|
||
messages.append({"role": "tool", "content": result, "tool_call_id": tc.id})
|
||
|
||
if rounds < MAX_TOOL_ROUNDS:
|
||
# Model may chain another tool call if it needs to
|
||
response = await llm_create(
|
||
model=LLM_MODEL,
|
||
messages=messages,
|
||
tools=TOOLS,
|
||
tool_choice="auto",
|
||
max_tokens=2048,
|
||
temperature=0.7,
|
||
)
|
||
else:
|
||
# Round budget spent — force a plain-text answer
|
||
log.warning(f"Tool round limit ({MAX_TOOL_ROUNDS}) reached — forcing final answer")
|
||
response = await llm_create(
|
||
model=LLM_MODEL,
|
||
messages=messages,
|
||
max_tokens=2048,
|
||
temperature=0.7,
|
||
)
|
||
msg = response.choices[0].message
|
||
tool_calls = (msg.tool_calls or []) if rounds < MAX_TOOL_ROUNDS else []
|
||
|
||
reply = sanitize_reply(msg.content or "")
|
||
if not reply:
|
||
# Model produced nothing (or only tool markup). One retry with an
|
||
# explicit instruction — this is what caused the bare "…" replies.
|
||
log.warning(
|
||
f"Empty final answer (finish_reason="
|
||
f"{response.choices[0].finish_reason}) — retrying once with nudge"
|
||
)
|
||
reply = await _nudge_final(messages)
|
||
return reply or "…"
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# TELEGRAM HANDLERS
|
||
# ══════════════════════════════════════════════
|
||
async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
await asyncio.to_thread(
|
||
upsert_user,
|
||
str(update.effective_user.id),
|
||
update.effective_user.username or "",
|
||
update.effective_user.full_name,
|
||
)
|
||
owner_hint = "\n\n🔑 És o owner deste bot." if is_owner(update) else ""
|
||
await update.message.reply_text(
|
||
f"👋 Olá {update.effective_user.first_name}! Sou o **{BOT_NAME}** 😊\n\n"
|
||
f"Menciona o meu nome numa mensagem para eu responder!\n\n"
|
||
f"Comandos:\n"
|
||
f"/memorias – ver as tuas memórias\n"
|
||
f"/esquecer `<n>` – apagar memória nº n\n"
|
||
f"/ajuda – mostrar esta mensagem\n"
|
||
f"\n*Comandos de owner:*\n"
|
||
f"/apagarmem `<user_id>` – apagar memórias de um utilizador\n"
|
||
f"/apagartudo – apagar TODAS as memórias do bot\n"
|
||
f"/novachat – limpar histórico deste grupo"
|
||
+ owner_hint,
|
||
parse_mode="Markdown"
|
||
)
|
||
|
||
async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
await cmd_start(update, ctx)
|
||
|
||
async def cmd_memories(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
uid = str(update.effective_user.id)
|
||
rows = await asyncio.to_thread(get_all_memories_indexed, uid)
|
||
if not rows:
|
||
await update.message.reply_text("🧠 Ainda não tenho memórias tuas. Fala comigo!")
|
||
return
|
||
text = f"🧠 **As tuas memórias ({BOT_NAME}):**\n\n" + "\n".join(f"{i+1}. {m}" for i, (_, m) in enumerate(rows))
|
||
text += "\n\nUsa /esquecer `<número>` para apagar uma."
|
||
await update.message.reply_text(text, parse_mode="Markdown")
|
||
|
||
async def cmd_forget(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
uid = str(update.effective_user.id)
|
||
args = ctx.args
|
||
if not args or not args[0].isdigit():
|
||
await update.message.reply_text("Uso: /esquecer `<número>` (obtém números com /memorias)", parse_mode="Markdown")
|
||
return
|
||
rows = await asyncio.to_thread(get_all_memories_indexed, uid)
|
||
idx = int(args[0]) - 1
|
||
if 0 <= idx < len(rows):
|
||
await asyncio.to_thread(delete_memory_by_id, rows[idx][0])
|
||
await update.message.reply_text("✅ Memória apagada.")
|
||
else:
|
||
await update.message.reply_text("❌ Número inválido.")
|
||
|
||
@owner_only
|
||
async def cmd_clear_user_memories(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
if not ctx.args:
|
||
await update.message.reply_text("Uso: /apagarmem `<user_id>`", parse_mode="Markdown")
|
||
return
|
||
await asyncio.to_thread(clear_memories, ctx.args[0])
|
||
await update.message.reply_text(f"🗑️ Memórias do utilizador `{ctx.args[0]}` apagadas.", parse_mode="Markdown")
|
||
|
||
@owner_only
|
||
async def cmd_clearall(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
await asyncio.to_thread(clear_all_memories)
|
||
await update.message.reply_text(f"🗑️ Todas as memórias do {BOT_NAME} foram apagadas.")
|
||
|
||
@owner_only
|
||
async def cmd_newchat(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
await asyncio.to_thread(clear_history, str(update.effective_chat.id))
|
||
await update.message.reply_text("🔄 Histórico do grupo limpo! (Memórias de longo prazo mantidas.)")
|
||
|
||
|
||
async def handle_message(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
|
||
if not update.message or not update.message.text:
|
||
return
|
||
|
||
user = update.effective_user
|
||
uid = str(user.id)
|
||
chat_id = str(update.effective_chat.id)
|
||
text = update.message.text
|
||
fname = user.first_name or "utilizador"
|
||
|
||
await asyncio.to_thread(upsert_user, uid, user.username or "", user.full_name or fname)
|
||
|
||
if not is_mentioned(text):
|
||
# Store + embed in the background — no reason to make the handler
|
||
# wait on Ollama for a message the bot won't answer.
|
||
fire_and_forget(store_message(chat_id, uid, fname, "user", text))
|
||
log.debug(f"[{BOT_NAME}] Storing silently: {text[:60]}")
|
||
return
|
||
|
||
# Mentioned: store BEFORE generating, and await it — chat_with_groq
|
||
# reads this message back from the history table (it must not be
|
||
# appended a second time there).
|
||
await store_message(chat_id, uid, fname, "user", text)
|
||
|
||
await update.message.chat.send_action("typing")
|
||
|
||
error_reply = False
|
||
try:
|
||
reply = await chat_with_groq(chat_id, uid, fname, text)
|
||
except Exception as e:
|
||
log.error(f"Groq error: {e}\n{traceback.format_exc()}")
|
||
reply = "⚠️ Ocorreu um erro. Tenta novamente."
|
||
error_reply = True
|
||
|
||
if not error_reply:
|
||
fire_and_forget(store_message(chat_id, None, BOT_NAME, "assistant", reply))
|
||
|
||
for chunk in [reply[i:i+4096] for i in range(0, len(reply), 4096)]:
|
||
if not chunk.strip():
|
||
continue
|
||
try:
|
||
await update.message.chat.send_message(chunk, parse_mode="Markdown")
|
||
except Exception:
|
||
try:
|
||
await update.message.chat.send_message(chunk)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
# ══════════════════════════════════════════════
|
||
# MAIN
|
||
# ══════════════════════════════════════════════
|
||
def main():
|
||
if not TELEGRAM_BOT_TOKEN:
|
||
raise ValueError("TELEGRAM_BOT_TOKEN not set — check .env_credentials")
|
||
if LLM_PROVIDER == "groq" and not GROQ_API_KEY:
|
||
raise ValueError("GROQ_API_KEY not set — check .env_credentials")
|
||
if LLM_PROVIDER == "openrouter" and not OPENROUTER_API_KEY:
|
||
raise ValueError("OPENROUTER_API_KEY not set — check .env_credentials")
|
||
if OWNER_ID == 0:
|
||
log.warning("OWNER_TELEGRAM_ID not set — admin commands blocked for everyone.")
|
||
|
||
init_db()
|
||
log.info(f"Starting {BOT_NAME} | trigger='{BOT_TRIGGER}' | provider={LLM_PROVIDER} | model={LLM_MODEL} | embed={EMBED_MODEL}@{OLLAMA_URL}")
|
||
|
||
app = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
|
||
|
||
app.add_handler(CommandHandler("start", cmd_start))
|
||
app.add_handler(CommandHandler("ajuda", cmd_help))
|
||
app.add_handler(CommandHandler("help", cmd_help))
|
||
app.add_handler(CommandHandler("memorias", cmd_memories))
|
||
app.add_handler(CommandHandler("esquecer", cmd_forget))
|
||
app.add_handler(CommandHandler("apagarmem", cmd_clear_user_memories))
|
||
app.add_handler(CommandHandler("apagartudo", cmd_clearall))
|
||
app.add_handler(CommandHandler("novachat", cmd_newchat))
|
||
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
|
||
|
||
app.run_polling(allowed_updates=Update.ALL_TYPES)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|