base90-rag 0.2.0__tar.gz → 0.2.2__tar.gz

{base90_rag-0.2.0 → base90_rag-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base90-rag
-Version: 0.2.0
+Version: 0.2.2
 Summary: 超极速、零算力、零幻觉的纯文本 RAG 检索结构 (Base90 极简硬路由)
 Author-email: Flowerdance <admin@example.com>
 License: MIT

{base90_rag-0.2.0 → base90_rag-0.2.2}/base90_rag/core.py

@@ -3,12 +3,10 @@ import os
 import sqlite3
 import threading
 import time
-import math
 import re
 import string
 import hashlib
 import pkgutil
-import heapq
 import unicodedata
 
 
@@ -199,76 +197,56 @@ class Base90Memory:
                         c.execute("INSERT OR IGNORE INTO inverted_index VALUES (?, ?)", (code, pointer_id))
         return pointer_id
 
-    def search(self, query: str, limit=2) -> list:
+    def search(self, query: str, limit=10) -> list:
         query_codes = set(self._extract_codes(query))
         if not query_codes: return []
 
-        hit_map = {}
-        hit_word_counts = {}
-        query_word_count = len(query_codes)
-        MAX_POSTINGS = 2000
-
         valid_sets = []
         for code in query_codes:
             if code in self.mem_inverted:
                 word = self.code_to_word.get(code, "")
-                if len(word) < 2 and not word.isalnum():
-                    continue
-                if len(word) == 1 and word in "的了是我你他她它":
-                    continue
-                valid_sets.append((code, self.mem_inverted[code], word))
+                if len(word) == 1 and word in "的了是我你他她它": continue
+                if len(word) == 1 and word.isascii() and word.isalpha(): continue
+
+                valid_sets.append(self.mem_inverted[code])
 
-        if not valid_sets:
-            return []
+        if not valid_sets: return []
 
-        valid_sets.sort(key=lambda x: len(x[1]))
+        valid_sets.sort(key=len)
 
-        candidate_pids = valid_sets[0][1]
+        candidate_pids = valid_sets[0].copy()
         for i in range(1, len(valid_sets)):
-            candidate_pids = candidate_pids.intersection(valid_sets[i][1])
+            candidate_pids = candidate_pids.intersection(valid_sets[i])
             if not candidate_pids:
                 break
 
-        if not candidate_pids:
-            return []
-
-        if len(candidate_pids) > MAX_POSTINGS:
+        if len(candidate_pids) > 2000:
             from itertools import islice
-            candidate_pids = set(islice(candidate_pids, MAX_POSTINGS))
+            candidate_pids = set(islice(candidate_pids, 2000))
 
-        for pid in candidate_pids:
-            for code, inv_list, word in valid_sets:
-                weight = max(1.0, len(word) * 1.5 - 0.5)
-                hit_map[pid] = hit_map.get(pid, 0) + weight
-                hit_word_counts[pid] = hit_word_counts.get(pid, 0) + 1
+        final_results = []
 
-        if not hit_map:
-            return []
+        if candidate_pids:
+            for pid in candidate_pids:
+                v = self.mem_vaults.get(pid)
+                if v and query in v["text"]:
+                    final_results.append(v["text"])
+                    if len(final_results) >= limit:
+                        return final_results
 
-        if len(hit_map) > 500:
-            top_500_items = heapq.nlargest(500, hit_map.items(), key=lambda x: x[1])
-            hit_map = dict(top_500_items)
-
-        scored = []
-        now = time.time()
-        for pid, hit_score in hit_map.items():
+        count = 0
+        for pid in valid_sets[0]:
             v = self.mem_vaults.get(pid)
-            if v:
-                age_days = (now - v["abs_timestamp"]) / 86400.0
-                time_decay = math.exp(-age_days / 30.0)
-
-                coverage = hit_word_counts.get(pid, 0) / query_word_count
-                coverage_penalty = 0.5 + (0.5 * coverage)
-
-                final_score = hit_score * time_decay * coverage_penalty
-                scored.append({"text": v["text"], "score": final_score})
-
-        scored.sort(key=lambda x: x["score"], reverse=True)
-
-        if scored and scored[0]["score"] < 1.5:
-            return []
+            if v and v["text"] not in final_results:  # 去重
+                if query in v["text"]:  # 硬校验
+                    final_results.append(v["text"])
+                    if len(final_results) >= limit:
+                        break
+            count += 1
+            if count > 2000:
+                break
 
-        return [item["text"] for item in scored[:limit]]
+        return final_results
 
     def close(self):
         """显式关闭数据库，解决 Windows 下文件被占用报错的问题"""

{base90_rag-0.2.0 → base90_rag-0.2.2}/base90_rag.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base90-rag
-Version: 0.2.0
+Version: 0.2.2
 Summary: 超极速、零算力、零幻觉的纯文本 RAG 检索结构 (Base90 极简硬路由)
 Author-email: Flowerdance <admin@example.com>
 License: MIT

{base90_rag-0.2.0 → base90_rag-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "base90-rag"
-version = "0.2.0"
+version = "0.2.2"
 authors = [
   { name="Flowerdance", email="admin@example.com" }
 ]