| """Norovox Embed Zero Agent — hafıza, web araştırması, kendi kendine öğrenme ve uzun bağlam; Norovox Embed Zero vektörleri üzerinde. |
| |
| from norovox_embed import NorovoxEmbed |
| from norovox_embed.agent import Agent |
| a = Agent(NorovoxEmbed.from_pretrained()) # düşünen çekirdek: varsayılan yerel Norovox Alpha |
| print(a.chat("İstanbul'da dere ıslahı neden sel riskini artırır?")) |
| |
| Ne yapar: |
| * HAFIZA (unutmaz): her konuşma turu, okunan her web parçası ve öğrenilen her bilgi Embed vektörüyle diske yazılır |
| (~/.norovox/memory). Yeni soruda en ilgili eski turlar ve bilgiler benzerlikle geri çağrılır → bağlam penceresi dolsa da |
| hiçbir şey kaybolmaz. |
| * WEB ARAŞTIRMASI: hafızada yeterince ilgili bilgi yoksa (benzerlik eşiği) ya da düşünen çekirdek ARA: komutu verirse web'de |
| arar (DuckDuckGo HTML + Wikipedia), sayfaları okur, parçalara böler, Embed ile sıralar, en iyi parçaları kaynaklarıyla verir. |
| * KENDİ KENDİNE ÖĞRENME: web'den gelen ve cevapta kullanılan parçalar hafızaya "öğrenildi" olarak eklenir; aynı konu bir daha |
| sorulduğunda web'e çıkmadan cevaplanır. |
| * UZUN/ZOR İŞLER: plan → ara → oku → yeniden ara (en çok `max_steps` tur) → cevap; her adımın gerekçesi `trace` içinde. |
| * DÜŞÜNEN ÇEKİRDEK takılabilir: `NorovoxAlphaThinker` (kendi çekirdeğimiz, yerel) ya da OpenAI-uyumlu herhangi bir uç nokta |
| (`EndpointThinker`, ör. llama-server). Konuşma kalitesi takılan çekirdeğe bağlıdır; hafıza/arama/öğrenme Embed'in işidir. |
| """ |
| from __future__ import annotations |
|
|
| import html |
| import json |
| import os |
| import re |
| import time |
| import urllib.parse |
| import urllib.request |
|
|
| import numpy as np |
|
|
| UA = {"User-Agent": "NorovoxEmbedAgent/0.1 (https://huggingface.co/emrevrg/Norovox-Embed-Zero)"} |
| _CACHE = {} |
|
|
|
|
| |
| class Memory: |
| """Kalıcı vektör hafıza: metin + tür + kaynak + zaman; vektörler float16 (768) diske yazılır.""" |
|
|
| def __init__(self, embed, path=None): |
| self.e = embed |
| self.path = path or os.path.join(os.path.expanduser("~"), ".norovox", "memory") |
| os.makedirs(self.path, exist_ok=True) |
| self.meta_p, self.vec_p = os.path.join(self.path, "meta.jsonl"), os.path.join(self.path, "vec.npy") |
| self.meta = [json.loads(l) for l in open(self.meta_p, encoding="utf-8")] if os.path.exists(self.meta_p) else [] |
| self.V = np.load(self.vec_p).astype(np.float32) if os.path.exists(self.vec_p) else np.zeros((0, 768), np.float32) |
| self._keys = {m["key"] for m in self.meta} |
|
|
| @staticmethod |
| def _key(t): |
| return re.sub(r"\W+", "", t.lower())[:200] |
|
|
| def add(self, texts, kind="note", source=""): |
| texts = [t for t in texts if t and t.strip() and self._key(t) not in self._keys] |
| if not texts: |
| return 0 |
| v = self.e.encode(texts, kind="document") |
| with open(self.meta_p, "a", encoding="utf-8") as f: |
| for t in texts: |
| m = {"text": t, "kind": kind, "source": source, "t": time.time(), "key": self._key(t)} |
| self.meta.append(m); self._keys.add(m["key"]); f.write(json.dumps(m, ensure_ascii=False) + "\n") |
| self.V = np.concatenate([self.V, v.astype(np.float32)]) if len(self.V) else v.astype(np.float32) |
| np.save(self.vec_p, self.V.astype(np.float16)) |
| return len(texts) |
|
|
| def search(self, query, k=6, kinds=None): |
| if not len(self.V): |
| return [] |
| q = self.e.encode([query], kind="query")[0] |
| s = self.V @ q |
| idx = np.argsort(-s) |
| out = [] |
| for i in idx: |
| if kinds and self.meta[i]["kind"] not in kinds: |
| continue |
| out.append({**self.meta[i], "score": float(s[i])}) |
| if len(out) >= k: |
| break |
| return out |
|
|
| def __len__(self): |
| return len(self.meta) |
|
|
|
|
| |
| def _get(url, timeout=12, tries=3): |
| """GET + önbellek; 429/5xx'te artan beklemeyle yeniden dener (sunucu kısıtlamasına saygı).""" |
| if url in _CACHE: |
| return _CACHE[url] |
| import urllib.error |
| for i in range(tries): |
| try: |
| req = urllib.request.Request(url, headers=UA) |
| with urllib.request.urlopen(req, timeout=timeout) as r: |
| raw = r.read(2_000_000) |
| cs = r.headers.get_content_charset() or "utf-8" |
| _CACHE[url] = raw.decode(cs, errors="replace") |
| return _CACHE[url] |
| except urllib.error.HTTPError as e: |
| if e.code in (429, 500, 502, 503, 504) and i < tries - 1: |
| time.sleep(int(e.headers.get("Retry-After", "0") or 0) or 2 * (i + 1)); continue |
| raise |
| except urllib.error.URLError: |
| if i < tries - 1: |
| time.sleep(2 * (i + 1)); continue |
| raise |
|
|
|
|
| def _text(page): |
| page = re.sub(r"(?is)<(script|style|noscript|header|footer|nav|svg)[^>]*>.*?</\1>", " ", page) |
| page = re.sub(r"(?s)<[^>]+>", " ", page) |
| return re.sub(r"\s+", " ", html.unescape(page)).strip() |
|
|
|
|
| STOP = set("""ve veya ile ama fakat de da mi mı mu mü ne neden nasıl niçin niye hangi kim kime nedir midir mıdır mudur müdür bir bu şu o |
| için gibi kadar daha çok en çok az olarak olan olur olursa olunca ise ki ya yani tekrar açıklar açıklar mısın misin musun anlat söyle |
| artar azalır nelerdir nerede ne zaman zaman the a an of to in on for and or is are was were why how what which who when where does do |
| did can could would should will explain again about with from that this these those it its as by be been""".split()) |
|
|
|
|
| def keywords(q, n=6): |
| """Uzun soru → arama motoruna uygun kısa anahtar sözcük sorgusu (durak sözcükler atılır, sıra korunur).""" |
| w = [x for x in re.findall(r"[\wçğıöşüÇĞİÖŞÜ]+", q.lower()) if x not in STOP and len(x) > 2] |
| return " ".join(w[:n]) |
|
|
|
|
| def web_search(query, n=6): |
| """Resmi, anahtarsız uç noktalar: Wikipedia tam metin arama (tr + en) + DuckDuckGo Instant Answer API. |
| İsteğe bağlı: NOROVOX_SEARXNG=<url> (kendi SearXNG sunucun) ya da NOROVOX_BRAVE_KEY=<anahtar> (Brave Search API). |
| Dönen: [(başlık, url)]; Wikipedia sayfaları read_chunks'ta düz metin API'siyle okunur.""" |
| out = [] |
| sx, bk = os.environ.get("NOROVOX_SEARXNG"), os.environ.get("NOROVOX_BRAVE_KEY") |
| try: |
| if sx: |
| j = json.loads(_get(sx.rstrip("/") + "/search?format=json&q=" + urllib.parse.quote(query))) |
| out += [(r.get("title", ""), r["url"]) for r in j.get("results", [])[:n]] |
| if bk: |
| req = urllib.request.Request("https://api.search.brave.com/res/v1/web/search?q=" + urllib.parse.quote(query), |
| headers={**UA, "Accept": "application/json", "X-Subscription-Token": bk}) |
| with urllib.request.urlopen(req, timeout=12) as r: |
| j = json.loads(r.read()) |
| out += [(r.get("title", ""), r["url"]) for r in j.get("web", {}).get("results", [])[:n]] |
| except Exception: |
| pass |
| for lang in ("tr", "en"): |
| try: |
| j = json.loads(_get(f"https://{lang}.wikipedia.org/w/api.php?action=query&list=search&format=json&srlimit=3&srsearch=" |
| + urllib.parse.quote(query))) |
| out += [(r["title"], f"https://{lang}.wikipedia.org/wiki/" + urllib.parse.quote(r["title"].replace(" ", "_"))) |
| for r in j["query"]["search"]] |
| except Exception: |
| pass |
| try: |
| j = json.loads(_get("https://api.duckduckgo.com/?format=json&no_html=1&q=" + urllib.parse.quote(query))) |
| if j.get("AbstractURL"): |
| out.append((j.get("Heading", ""), j["AbstractURL"])) |
| for t in j.get("RelatedTopics", [])[:3]: |
| if isinstance(t, dict) and t.get("FirstURL"): |
| out.append((t.get("Text", "")[:80], t["FirstURL"])) |
| except Exception: |
| pass |
| seen, res = set(), [] |
| for t, u in out: |
| if u not in seen: |
| seen.add(u); res.append((t, u)) |
| return res[:n] |
|
|
|
|
| def _page_text(url): |
| m = re.match(r"https://(\w+)\.wikipedia\.org/wiki/(.+)", url) |
| if m: |
| j = json.loads(_get(f"https://{m.group(1)}.wikipedia.org/w/api.php?action=query&prop=extracts&explaintext=1&format=json&titles=" |
| + m.group(2))) |
| return " ".join(p.get("extract", "") for p in j["query"]["pages"].values()) |
| return _text(_get(url)) |
|
|
|
|
| def read_chunks(url, size=700, overlap=120, limit=40): |
| try: |
| t = re.sub(r"\s+", " ", _page_text(url)) |
| except Exception: |
| return [] |
| ch, i = [], 0 |
| while i < len(t) and len(ch) < limit: |
| ch.append(t[i:i + size]); i += size - overlap |
| return [c for c in ch if len(c) > 120] |
|
|
|
|
| |
| class EndpointThinker: |
| """OpenAI-uyumlu sohbet uç noktası (ör. llama-server --port 8080).""" |
|
|
| def __init__(self, url="http://127.0.0.1:8080/v1/chat/completions", model="local", max_tokens=700): |
| self.url, self.model, self.max_tokens = url, model, max_tokens |
|
|
| def __call__(self, messages): |
| body = json.dumps({"model": self.model, "messages": messages, "max_tokens": self.max_tokens, "temperature": 0.3}).encode() |
| req = urllib.request.Request(self.url, data=body, headers={"Content-Type": "application/json"}) |
| with urllib.request.urlopen(req, timeout=600) as r: |
| return json.loads(r.read())["choices"][0]["message"]["content"] |
|
|
|
|
| class NorovoxAlphaThinker: |
| """Kendi çekirdeğimiz (NorovoxAlphaCore, nedensel kip) ile yerel üretim; ağırlık deposu ve dosya adı ayarlanabilir.""" |
|
|
| def __init__(self, repo="emrevrg/Norovox-Alpha-0.3B", ckpt="norovox_alpha_sft.pt", device=None, max_new=400): |
| import sys |
| import torch |
| from huggingface_hub import hf_hub_download |
| from transformers import AutoTokenizer |
| sys.path.insert(0, os.path.dirname(hf_hub_download(repo, "norovox_alpha_core.py"))) |
| from norovox_alpha_core import NorovoxAlphaCore, CoreConfig |
| ck = torch.load(hf_hub_download(repo, ckpt), map_location="cpu", weights_only=False) |
| self.core = NorovoxAlphaCore(CoreConfig(**ck["cfg"])); self.core.load_state_dict(ck.get("model", ck), strict=False) |
| self.core.lm_head.weight = self.core.embed.weight |
| self.dev = device or ("cuda" if torch.cuda.is_available() else "cpu"); self.core.to(self.dev).eval() |
| self.tok, self.torch, self.max_new = AutoTokenizer.from_pretrained(repo), torch, max_new |
|
|
| def __call__(self, messages): |
| torch = self.torch |
| prompt = "".join(f"<|{m['role']}|>\n{m['content']}\n" for m in messages) + "<|assistant|>\n" |
| ids = torch.tensor([self.tok(prompt, add_special_tokens=False)["input_ids"][-1800:]], device=self.dev) |
| out = [] |
| with torch.no_grad(): |
| for _ in range(self.max_new): |
| lg = self.core(ids)["logits"][0, -1].float() |
| nxt = int(torch.multinomial(torch.softmax(lg / 0.7, -1), 1)) |
| if nxt == self.tok.eos_token_id: |
| break |
| out.append(nxt); ids = torch.cat([ids, torch.tensor([[nxt]], device=self.dev)], 1) |
| if len(out) % 16 == 0 and "<|" in self.tok.decode(out[-16:]): |
| break |
| return self.tok.decode(out, skip_special_tokens=True).split("<|")[0].strip() |
|
|
|
|
| |
| SYSTEM = ("Sen Norovox'sun. Cevabı yalnız verilen BAĞLAM ve HAFIZA'ya dayandır, kaynak numarası ver [1]. Bilgi yetmiyorsa tek satır " |
| "'ARA: <arama sorgusu>' yaz (başka bir şey yazma). Zor işlerde önce kısa bir plan yaz, sonra adım adım yürü, sonunda net cevap ver.") |
|
|
|
|
| class Agent: |
| def __init__(self, embed, thinker=None, memory_path=None, web=True, recall_min=0.6, max_steps=3, budget_chars=6000): |
| self.e, self.mem = embed, Memory(embed, memory_path) |
| self.think = thinker |
| self.web, self.recall_min, self.max_steps, self.budget = web, recall_min, max_steps, budget_chars |
| self.history, self.trace = [], [] |
|
|
| def _thinker(self): |
| if self.think is None: |
| self.think = NorovoxAlphaThinker() |
| return self.think |
|
|
| def _covers(self, query, rec): |
| """Hafıza kaydı soruyu karşılıyor mu: benzerlik eşiği VE sorunun anahtar sözcüklerinden en az ikisi (tek sözcüklü soruda biri) |
| kayıtta geçiyor. Yalnız benzerlik yetmez: gömme uzayında ilgisiz metinler de orta düzey benzerlik alır.""" |
| kw = [w for w in keywords(query, 8).split() if len(w) > 2] |
| txt = rec["text"].lower() |
| need = min(2, len(kw)) if kw else 1 |
| return rec["score"] >= self.recall_min and sum(w[:6] in txt for w in kw) >= need |
|
|
| def research(self, query, k=6): |
| """Web: ara → oku → Embed ile parçaları sırala → en iyi k parça (kaynakla).""" |
| hits, seen = [], set() |
| for qq in dict.fromkeys([keywords(query), keywords(query, 3), query]): |
| for h in web_search(qq) if qq else []: |
| if h[1] not in seen: |
| seen.add(h[1]); hits.append(h) |
| if len(hits) >= 4: |
| break |
| chunks, src = [], [] |
| for title, url in hits[:5]: |
| for c in read_chunks(url): |
| chunks.append(c); src.append(url) |
| if not chunks: |
| return [] |
| q = self.e.encode([query], kind="query")[0]; D = self.e.encode(chunks, kind="document") |
| order = np.argsort(-(D @ q))[:k] |
| return [{"text": chunks[i], "source": src[i], "score": float(D[i] @ q)} for i in order] |
|
|
| def _context(self, query, web_hits): |
| recall = self.mem.search(query, k=8) |
| ctx, used = [], 0 |
| for i, r in enumerate(web_hits + [x for x in recall if x["kind"] != "turn"]): |
| s = f"[{i + 1}] ({r.get('source') or r.get('kind')}) {r['text']}" |
| if used + len(s) > self.budget: |
| break |
| ctx.append(s); used += len(s) |
| turns = [x for x in recall if x["kind"] == "turn"][:4] |
| return ctx, turns, recall |
|
|
| def chat(self, user): |
| self.trace = [] |
| query, web_hits = user, [] |
| recall = self.mem.search(user, k=4, kinds=("learned", "note", "web")) |
| if self.web and not any(self._covers(user, r) for r in recall): |
| web_hits = self.research(user); self.trace.append({"step": "web", "query": user, "hits": len(web_hits)}) |
| answer = "" |
| for step in range(self.max_steps): |
| ctx, turns, _ = self._context(query, web_hits) |
| msgs = [{"role": "system", "content": SYSTEM}] |
| if turns: |
| msgs.append({"role": "system", "content": "HAFIZA (eski konuşmalar):\n" + "\n".join(t["text"] for t in turns)}) |
| msgs += self.history[-6:] |
| msgs.append({"role": "user", "content": ("BAĞLAM:\n" + "\n".join(ctx) + "\n\nSORU: " if ctx else "") + user}) |
| answer = self._thinker()(msgs) |
| m = re.match(r"\s*ARA:\s*(.+)", answer) |
| if m and self.web and step < self.max_steps - 1: |
| query = m.group(1).strip(); more = self.research(query) |
| self.trace.append({"step": "web", "query": query, "hits": len(more)}); web_hits = more + web_hits |
| continue |
| break |
| if web_hits: |
| n = self.mem.add([h["text"] for h in web_hits[:4]], kind="learned", source=web_hits[0]["source"]) |
| self.trace.append({"step": "learn", "added": n}) |
| self.mem.add([f"Kullanıcı: {user}\nNorovox: {answer}"], kind="turn") |
| self.history += [{"role": "user", "content": user}, {"role": "assistant", "content": answer}] |
| return answer |
|
|
| def learn(self, texts, source="kullanıcı"): |
| """Doğrudan öğret: metinler hafızaya eklenir, sonraki sorularda kullanılır.""" |
| return self.mem.add(texts if isinstance(texts, list) else [texts], kind="note", source=source) |
|
|
|
|
| def main(): |
| """python -m norovox_embed.agent [--endpoint URL] [--memory DIR] [--no-web]""" |
| import argparse |
| from norovox_embed import NorovoxEmbed |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--model", default="emrevrg/Norovox-Embed-Zero"); ap.add_argument("--endpoint", default="") |
| ap.add_argument("--memory", default=None); ap.add_argument("--no-web", action="store_true") |
| a = ap.parse_args() |
| th = EndpointThinker(a.endpoint) if a.endpoint else None |
| ag = Agent(NorovoxEmbed.from_pretrained(a.model), thinker=th, memory_path=a.memory, web=not a.no_web) |
| print(f"Norovox — hafızada {len(ag.mem)} kayıt. Çıkmak için boş satır; öğretmek için: /öğren <metin>") |
| while True: |
| try: |
| u = input("> ").strip() |
| except EOFError: |
| break |
| if not u: |
| break |
| if u.startswith("/öğren "): |
| print("öğrenildi:", ag.learn(u[7:])); continue |
| print(ag.chat(u)); print(" ", ag.trace) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
