Upload knowledge_library.py with huggingface_hub

knowledge_library.py

@@ -0,0 +1,557 @@
+#!/usr/bin/env python3
+"""
+FSI_FELON · KNOWLEDGE LIBRARY
+Lightweight RAG for software engineering knowledge.
+No external deps — uses numpy for similarity + BM25-style keyword scoring.
+The model queries this when it doesn't know something, learns from it,
+and gradually internalizes the knowledge.
+"""
+
+import json, os, re, math
+from collections import Counter
+
+KNOWLEDGE_PATH = os.path.join(os.path.dirname(__file__) or '.', 'knowledge_library.json')
+
+# ═══════════════════════════════════════════════════════════
+# KNOWLEDGE ENTRIES — curated SE textbook content
+# ═══════════════════════════════════════════════════════════
+
+KNOWLEDGE_ENTRIES = [
+    # ── PYTHON BASICS ──
+    {
+        "topic": "python_functions",
+        "tags": ["python", "functions", "def", "arguments", "parameters", "return"],
+        "content": """Python Functions:
+- Define with `def name(params):`, body indented 4 spaces
+- Parameters: positional args, keyword args (name=value), *args (variadic), **kwargs (keyword variadic)
+- Default values: `def f(x=10)`. NEVER use mutable defaults like `def f(x=[])`.
+- Return values: `return value`. No return = returns None.
+- Type hints: `def add(a: int, b: int) -> int:`. Optional.
+- Docstrings: triple-quoted string right after def line.
+- Lambda: `lambda x: x*2` for inline anonymous functions."""
+    },
+    {
+        "topic": "python_classes",
+        "tags": ["python", "classes", "oop", "self", "inheritance", "methods"],
+        "content": """Python Classes:
+- Define with `class Name:`. Methods take `self` as first param.
+- `__init__(self, ...)` is constructor.
+- Instance variables: `self.var = value` inside __init__.
+- Inheritance: `class Child(Parent):`. Call `super().__init__()` in child __init__.
+- `@property` decorator for computed attributes.
+- `@staticmethod` for methods that don't need self.
+- `@classmethod` with `cls` as first param for factory methods.
+- `__str__` for string representation, `__repr__` for debugging representation."""
+    },
+    {
+        "topic": "python_imports",
+        "tags": ["python", "import", "modules", "packages", "from"],
+        "content": """Python Imports:
+- `import module` imports the whole module. Access with `module.name`.
+- `from module import name` imports specific name into current namespace.
+- `from module import *` imports all public names (avoid this).
+- `import module as alias` for shorter names.
+- `from module import name as alias` for renaming.
+- Packages: directory with `__init__.py` file. Example: `from package.module import name`.
+- Common imports: `import os`, `import sys`, `import json`, `import re`, `import math`."""
+    },
+    {
+        "topic": "python_exceptions",
+        "tags": ["python", "exceptions", "error", "try", "except", "finally", "raise"],
+        "content": """Python Error Handling:
+- `try:` block contains code that might raise an exception.
+- `except ExceptionType as e:` catches specific exception types.
+- `except Exception as e:` catches (almost) all exceptions.
+- `else:` runs if no exception occurred.
+- `finally:` ALWAYS runs (cleanup code).
+- `raise ValueError("message")` to raise an exception.
+- Common exceptions: ValueError, TypeError, KeyError, IndexError, FileNotFoundError, ZeroDivisionError.
+- Context managers: `with open(path) as f:` auto-closes file even on error."""
+    },
+    {
+        "topic": "python_strings",
+        "tags": ["python", "strings", "format", "f-strings", "methods", "split", "join"],
+        "content": """Python String Operations:
+- f-strings: `f"Hello {name}"` for string formatting.
+- `.format()`: `"Hello {}".format(name)`.
+- `.split(sep)`: split into list by separator.
+- `.join(iterable)`: join list into string with separator.
+- `.strip()`, `.lstrip()`, `.rstrip()`: remove whitespace.
+- `.lower()`, `.upper()`, `.title()`, `.capitalize()`: case changes.
+- `.replace(old, new)`: replace substrings.
+- `.startswith(prefix)`, `.endswith(suffix)`: check prefixes/suffixes.
+- `.find(sub)`, `.index(sub)`: find substring position.
+- Slice: `s[start:end:step]`. Reverse: `s[::-1]`."""
+    },
+    {
+        "topic": "python_lists",
+        "tags": ["python", "lists", "list", "array", "comprehension", "append", "slice"],
+        "content": """Python Lists:
+- Create: `[1, 2, 3]` or `list(range(5))`.
+- `.append(item)`: add single item to end.
+- `.extend(iterable)`: add multiple items.
+- `.insert(index, item)`: insert at position.
+- `.pop(index)`: remove and return item at index (last if no index).
+- `.remove(value)`: remove first occurrence of value.
+- `.sort()`: sort in place. `.sort(reverse=True)` for descending.
+- `sorted(list)`: returns new sorted list.
+- List comprehension: `[x*2 for x in range(10) if x % 2 == 0]`.
+- Slice: `lst[start:end:step]`. Copy: `lst[:]`.
+- `len(lst)`, `min(lst)`, `max(lst)`, `sum(lst)`."""
+    },
+    {
+        "topic": "python_dicts",
+        "tags": ["python", "dictionary", "dict", "hashmap", "keys", "values", "items"],
+        "content": """Python Dictionaries:
+- Create: `{"key": "value"}` or `dict(a=1, b=2)`.
+- Access: `d["key"]`. Use `d.get("key", default)` to avoid KeyError.
+- Set: `d["key"] = value`.
+- `.keys()`, `.values()`, `.items()` for views.
+- `for k, v in d.items():` for iteration.
+- `key in d` to check existence.
+- `.pop(key)`, `.popitem()` to remove.
+- `.update(other_dict)` to merge.
+- Dict comprehension: `{x: x**2 for x in range(5)}`.
+- `defaultdict` from collections for default values.
+- `Counter` from collections for counting."""
+    },
+
+    # ── ALGORITHMS ──
+    {
+        "topic": "algorithm_sorting",
+        "tags": ["algorithm", "sort", "sorting", "bubble", "merge", "quick", "binary search"],
+        "content": """Common Sorting Algorithms:
+- Built-in: `sorted(list)` or `list.sort()`. Uses Timsort (O(n log n)).
+- `sorted(list, key=lambda x: x[1])` for custom sort key.
+- `sorted(list, reverse=True)` for descending.
+- Binary search: `bisect_left(list, x)` from bisect module.
+- Sort by multiple criteria: `sorted(list, key=lambda x: (x.age, x.name))`.
+- Partial sort: `heapq.nsmallest(k, list)` or `heapq.nlargest(k, list)`.
+- Finding min/max with conditions: `min(list, key=func)`."""
+    },
+    {
+        "topic": "algorithm_recursion",
+        "tags": ["algorithm", "recursion", "recursive", "base case", "stack", "memoization"],
+        "content": """Recursion:
+- A function that calls itself with smaller inputs.
+- Must have a BASE CASE to stop recursion (e.g., n <= 1).
+- Must make PROGRESS toward base case each call.
+- Stack limit: Python has ~1000 recursion depth limit.
+- Memoization: cache results with `@functools.lru_cache(maxsize=None)`.
+- Examples: factorial, fibonacci, tree traversal, divide-and-conquer.
+- Iterative alternative: use a stack (list) to simulate recursion.
+- Tail recursion: Python does NOT optimize tail recursion."""
+    },
+    {
+        "topic": "algorithm_search",
+        "tags": ["algorithm", "search", "linear", "binary", "bfs", "dfs", "graph"],
+        "content": """Search Algorithms:
+- Linear search: check each element O(n). Works on unsorted data.
+- Binary search: divide-and-conquer on sorted data O(log n). Use bisect module.
+- BFS (Breadth-First Search): uses queue, finds shortest path in unweighted graph.
+- DFS (Depth-First Search): uses stack or recursion, good for exhaustive search.
+- Dijkstra: shortest path in weighted graph. Use `heapq` for priority queue.
+- A*: heuristic-guided search for pathfinding.
+- Graph representation: adjacency list `{node: [neighbors]}` or matrix."""
+    },
+
+    # ── TESTING ──
+    {
+        "topic": "testing_basics",
+        "tags": ["testing", "pytest", "unittest", "assert", "test", "tdd"],
+        "content": """Python Testing:
+- Use pytest: `pip install pytest`. Run with `pytest` command.
+- Test files named `test_*.py` or `*_test.py`.
+- Test functions named `test_*`.
+- Use `assert` for checks: `assert add(2, 3) == 5`.
+- pytest discovers tests automatically.
+- Fixtures: use `@pytest.fixture` for setup/teardown.
+- `pytest.raises(ExceptionType)` for testing exceptions.
+- `pytest.mark.parametrize` for running same test with multiple inputs.
+- Coverage: `pytest --cov=module` to check code coverage.
+- Test categories: normal cases, edge cases, error cases, boundary values."""
+    },
+    {
+        "topic": "testing_patterns",
+        "tags": ["testing", "mock", "patch", "fixture", "integration", "unit"],
+        "content": """Testing Patterns:
+- Unit test: tests a single function/method in isolation.
+- Integration test: tests multiple components together.
+- Mock: `unittest.mock.patch` or `pytest-mock` to replace dependencies.
+- Arrange-Act-Assert: set up data, execute code, verify result.
+- Given-When-Then: BDD style of describing tests.
+- Test doubles: Dummy, Stub, Spy, Mock, Fake.
+- Coverage metrics: line coverage, branch coverage, path coverage.
+- Property-based testing: `hypothesis` library generates random inputs.
+- Snapshot testing: compare output to saved reference."""
+    },
+
+    # ── CODE QUALITY ──
+    {
+        "topic": "code_quality_linting",
+        "tags": ["code quality", "lint", "linter", "pylint", "flake8", "formatting"],
+        "content": """Code Quality:
+- Linting: automated checking for errors and style issues.
+- flake8: checks PEP 8 style, syntax errors, complexity.
+- pylint: more thorough checking, generates quality score.
+- black: opinionated code formatter (auto-fixes formatting).
+- isort: sorts imports alphabetically.
+- mypy: static type checker for type hints.
+- ruff: fast Rust-based linter and formatter (combines flake8+isort+more).
+- pre-commit: runs checks before git commit.
+- PEP 8: 79-char lines, 4-space indent, snake_case functions, CamelCase classes."""
+    },
+
+    # ── GIT ──
+    {
+        "topic": "git_basics",
+        "tags": ["git", "version control", "commit", "branch", "merge", "clone"],
+        "content": """Git Basics:
+- `git init`: initialize new repository.
+- `git clone <url>`: copy remote repository.
+- `git add <file>`: stage changes. `git add .` for all changes.
+- `git commit -m "message"`: save staged changes.
+- `git status`: see current state of working directory.
+- `git log`: view commit history. `git log --oneline` for compact view.
+- `git diff`: see unstaged changes. `git diff --staged` for staged changes.
+- `git branch <name>`: create branch. `git checkout <name>`: switch branch.
+- `git merge <branch>`: merge branch into current branch.
+- `git push`: upload commits to remote. `git pull`: download and merge."""
+    },
+
+    # ── FILE I/O ──
+    {
+        "topic": "file_io",
+        "tags": ["python", "file", "io", "read", "write", "csv", "json", "open"],
+        "content": """Python File I/O:
+- Read: `with open(path) as f: content = f.read()`.
+- Read lines: `with open(path) as f: lines = f.readlines()`.
+- Write: `with open(path, 'w') as f: f.write(content)`.
+- Append: `with open(path, 'a') as f: f.write(content)`.
+- CSV: `import csv`. `csv.reader(f)` to read. `csv.writer(f)` to write.
+- JSON: `json.load(f)` to read. `json.dump(data, f)` to write. `json.dumps(obj)` to string.
+- Binary: `open(path, 'rb')` / `open(path, 'wb')`.
+- Path: use `os.path.join(dir, file)` for cross-platform paths.
+- Directory: `os.makedirs(path, exist_ok=True)`. `os.listdir(path)`.
+- Check exists: `os.path.exists(path)`. `os.path.isfile(path)`."""
+    },
+
+    # ── SECURITY ──
+    {
+        "topic": "security_basics",
+        "tags": ["security", "injection", "validation", "xss", "sql", "sanitize"],
+        "content": """Security Best Practices:
+- Input validation: NEVER trust user input. Validate type, length, format.
+- SQL injection: use parameterized queries, never string concatenation.
+- XSS (Cross-Site Scripting): escape output in HTML context.
+- eval() is DANGEROUS: use `ast.literal_eval()` for safe evaluation.
+- exec() is DANGEROUS: avoid entirely. Use restricted environments if necessary.
+- Password hashing: use bcrypt, argon2, or hashlib with salt.
+- HTTPS: always use for network communication.
+- Secret management: use environment variables, never hardcode secrets.
+- Dependency scanning: check for known vulnerabilities (Dependabot).
+- Principle of least privilege: give minimum necessary permissions."""
+    },
+    {
+        "topic": "security_sql_injection",
+        "tags": ["security", "sql", "injection", "parameterized", "prepared"],
+        "content": """SQL Injection Prevention:
+- BAD: `f"SELECT * FROM users WHERE name = '{name}'"` — allows injection.
+- GOOD: use parameterized queries: `cursor.execute("SELECT * FROM users WHERE name = ?", (name,))`.
+- ORMs (SQLAlchemy, Django) auto-parameterize queries.
+- Escape special characters if you must build strings.
+- Use stored procedures for complex operations.
+- Validate input: reject unexpected characters.
+- Limit database permissions per application user.
+- Monitor for injection attempts in logs."""
+    },
+
+    # ── DESIGN PATTERNS ──
+    {
+        "topic": "design_patterns_creational",
+        "tags": ["design patterns", "singleton", "factory", "builder", "prototype"],
+        "content": """Creational Design Patterns:
+- Singleton: ensure class has exactly one instance. Module-level variable in Python.
+- Factory: factory function returns objects without specifying exact class.
+- Factory Method: subclass decides which class to instantiate.
+- Abstract Factory: create families of related objects.
+- Builder: separate construction from representation. Build step-by-step.
+- Prototype: clone existing objects instead of creating new ones.
+- Python-specific: use `__new__` for singleton. Use classmethods as factories."""
+    },
+
+    # ── CONCURRENCY ──
+    {
+        "topic": "python_concurrency",
+        "tags": ["python", "concurrent", "threading", "async", "multiprocessing", "asyncio"],
+        "content": """Python Concurrency:
+- Threading: `import threading`. Thread(target=func, args=(...)). GIL limits CPU parallelism.
+- Multiprocessing: `import multiprocessing`. Process(target=func). True parallelism.
+- asyncio: `async def`, `await`, `asyncio.run()`. Cooperative multitasking for I/O.
+- concurrent.futures: ThreadPoolExecutor for threads, ProcessPoolExecutor for processes.
+- Lock: prevent race conditions. `threading.Lock()`. Use `with lock:`.
+- Queue: thread-safe queue. `queue.Queue()`. For producer-consumer patterns.
+- Use asyncio for: web servers, API calls, file I/O operations.
+- Use multiprocessing for: CPU-heavy computations, data processing."""
+    },
+
+    # ── WEB ──
+    {
+        "topic": "web_requests",
+        "tags": ["web", "http", "requests", "api", "rest", "get", "post"],
+        "content": """HTTP Requests in Python:
+- `import requests`. Install: `pip install requests`.
+- GET: `r = requests.get(url, params={"key": "value"})`.
+- POST: `r = requests.post(url, json={"key": "value"})`.
+- Response: `r.status_code`, `r.json()`, `r.text`, `r.headers`.
+- Timeout: `requests.get(url, timeout=5)` to avoid hanging.
+- Error handling: `r.raise_for_status()` or check `r.status_code`.
+- Headers: `requests.get(url, headers={"Authorization": "Bearer token"})`.
+- Session: `s = requests.Session()` for persistent connections and cookies.
+- Authentication: `requests.get(url, auth=("user", "pass"))`."""
+    },
+
+    # ── DATA STRUCTURES ──
+    {
+        "topic": "data_structures_advanced",
+        "tags": ["data structures", "heap", "queue", "stack", "tree", "graph", "hash"],
+        "content": """Advanced Python Data Structures:
+- Heap (min): `import heapq`. `heapq.heappush(heap, item)`. `heapq.heappop(heap)`.
+- Heap (max): push negative values, or use custom key with wrapper.
+- Queue (FIFO): `from collections import deque`. `d.append()` / `d.popleft()`.
+- Stack (LIFO): use list. `.append()` / `.pop()`.
+- Priority Queue: `from queue import PriorityQueue` (thread-safe) or heapq.
+- Default dict: `from collections import defaultdict(lambda: 0)`.
+- Ordered dict: `from collections import OrderedDict` (Python 3.7+ dicts are ordered).
+- Named tuple: `from collections import namedtuple`. `Point = namedtuple('Point', ['x', 'y'])`.
+- ChainMap: combine multiple dicts.
+- Counter: `from collections import Counter`. `Counter(list).most_common(3)`."""
+    },
+
+    # ── TOOL CALL FORMAT ──
+    {
+        "topic": "tool_call_format",
+        "tags": ["tool", "json", "format", "nanobot", "api", "function calling"],
+        "content": """Tool Call JSON Format:
+- Write file: {"tool": "fs", "action": "write", "path": "filename.py", "content": "code here"}
+- Read file: {"tool": "fs", "action": "read", "path": "filename.py"}
+- List dir: {"tool": "fs", "action": "list", "path": "directory"}
+- Check exists: {"tool": "fs", "action": "exists", "path": "filename.py"}
+- Delete: {"tool": "fs", "action": "delete", "path": "filename.py"}
+- Create dir: {"tool": "fs", "action": "mkdir", "path": "directory"}
+- Compile check: {"tool": "compile", "path": "filename.py"}
+- Run tests: {"tool": "test", "path": "directory"}
+- Search code: {"tool": "search", "query": "pattern", "path": ".", "ext": ".py"}
+- Run command: {"tool": "shell", "cmd": "command string"}
+- Git init: {"tool": "git", "action": "init", "path": "."}
+- Git commit: {"tool": "git", "action": "commit", "message": "commit msg"}
+- Done: {"tool": "done"}
+
+Always emit JSON on a single line. After the tool call, include THOUGHT: and RESULT: on new lines."""
+    },
+]
+
+
+# ═══════════════════════════════════════════════════════════
+# KNOWLEDGE LIBRARY
+# ═══════════════════════════════════════════════════════════
+
+class KnowledgeLibrary:
+    """Lightweight RAG — BM25 + keyword scoring. No external deps."""
+
+    def __init__(self, path=KNOWLEDGE_PATH):
+        self.path = path
+        self.entries = []
+        self.k1 = 1.5  # BM25 parameter
+        self.b = 0.75  # BM25 parameter
+        self._loaded = False
+
+    def load(self):
+        if self._loaded:
+            return
+        if os.path.exists(self.path):
+            with open(self.path) as f:
+                self.entries = json.load(f)
+        else:
+            self.entries = KNOWLEDGE_ENTRIES
+            self.save()
+        self._loaded = True
+        # Build word frequency stats for BM25
+        self._build_stats()
+
+    def save(self):
+        with open(self.path, 'w') as f:
+            json.dump(self.entries, f, indent=2)
+
+    def _build_stats(self):
+        self.doc_lengths = [len(e["content"].split()) for e in self.entries]
+        self.avg_doc_len = sum(self.doc_lengths) / max(1, len(self.doc_lengths))
+        self.N = len(self.entries)
+        # Document frequency: how many docs contain each word
+        self.df = Counter()
+        for entry in self.entries:
+            words = set(self._tokenize(entry["content"]) + self._tokenize(entry["topic"]) + sum((self._tokenize(t) for t in entry.get("tags", [])), []))
+            for w in words:
+                self.df[w] += 1
+
+    def _tokenize(self, text):
+        return re.findall(r'[a-z0-9_]+', text.lower())
+
+    def _bm25_score(self, query_tokens, doc_idx):
+        """Score a single document against query tokens using BM25."""
+        entry = self.entries[doc_idx]
+        doc_tokens = self._tokenize(entry["content"]) + self._tokenize(entry["topic"])
+        doc_len = self.doc_lengths[doc_idx]
+        doc_tf = Counter(doc_tokens)
+
+        score = 0.0
+        for token in query_tokens:
+            if token not in doc_tf:
+                continue
+            tf = doc_tf[token]
+            df = self.df.get(token, 0)
+            # IDF
+            idf = math.log((self.N - df + 0.5) / (df + 0.5) + 1.0)
+            # BM25 TF component
+            tf_component = (tf * (self.k1 + 1)) / (tf + self.k1 * (1 - self.b + self.b * doc_len / self.avg_doc_len))
+            score += idf * tf_component
+
+        # Bonus for tag matches
+        query_set = set(query_tokens)
+        tag_tokens = set()
+        for tag in entry.get("tags", []):
+            tag_tokens.update(self._tokenize(tag))
+        tag_match = len(query_set & tag_tokens)
+        score += tag_match * 2.0  # Tag matches are strong signals
+
+        # Bonus for topic name match
+        topic_tokens = set(self._tokenize(entry["topic"]))
+        topic_match = len(query_set & topic_tokens)
+        score += topic_match * 3.0
+
+        return score
+
+    def query(self, question, top_k=3):
+        """Search the knowledge library for relevant entries."""
+        self.load()
+        query_tokens = self._tokenize(question)
+
+        if not query_tokens:
+            return []
+
+        scores = []
+        for i in range(len(self.entries)):
+            score = self._bm25_score(query_tokens, i)
+            if score > 0:
+                scores.append((score, i))
+
+        scores.sort(reverse=True)
+        results = []
+        for score, idx in scores[:top_k]:
+            entry = self.entries[idx]
+            results.append({
+                "topic": entry["topic"],
+                "score": round(score, 2),
+                "content": entry["content"],
+                "tags": entry.get("tags", []),
+            })
+
+        return results
+
+    def add_entry(self, topic, content, tags):
+        """Add a new knowledge entry (e.g., from web search results)."""
+        self.load()
+        entry = {"topic": topic, "content": content, "tags": tags}
+        self.entries.append(entry)
+        self.save()
+        self._loaded = False  # Rebuild stats on next query
+        return len(self.entries)
+
+    def list_topics(self):
+        self.load()
+        return [e["topic"] for e in self.entries]
+
+    def stats(self):
+        self.load()
+        return {
+            "total_entries": len(self.entries),
+            "avg_doc_len": round(self.avg_doc_len, 1),
+            "unique_terms": len(self.df),
+        }
+
+
+# ═══════════════════════════════════════════════════════════
+# QUERY TRACKER — tracks what the model learned
+# ═══════════════════════════════════════════════════════════
+
+class QueryTracker:
+    """Tracks library queries — shows knowledge gaps and learning progress."""
+
+    def __init__(self, path="library_queries.jsonl"):
+        self.path = path
+        self.queries = self._load()
+
+    def _load(self):
+        if os.path.exists(self.path):
+            with open(self.path) as f:
+                return [json.loads(l) for l in f if l.strip()]
+        return []
+
+    def log(self, task, question, results_used, success):
+        entry = {
+            "task": task[:200],
+            "question": question[:200],
+            "topics_used": [r["topic"] for r in results_used],
+            "success": success,
+        }
+        self.queries.append(entry)
+        with open(self.path, 'a') as f:
+            f.write(json.dumps(entry) + "\n")
+
+    def gap_analysis(self):
+        """Find which topics the model queries most often — those are gaps."""
+        topics = Counter()
+        for q in self.queries:
+            for t in q.get("topics_used", []):
+                topics[t] += 1
+        return topics.most_common()
+
+    def learning_curve(self, window=20):
+        """Track if library dependency is decreasing over time."""
+        if len(self.queries) < window:
+            return None
+        recent = self.queries[-window:]
+        earlier = self.queries[-window*2:-window] if len(self.queries) >= window*2 else self.queries[:window]
+        recent_rate = sum(1 for q in recent if q.get("topics_used")) / len(recent)
+        earlier_rate = sum(1 for q in earlier if q.get("topics_used")) / max(1, len(earlier))
+        return {
+            "recent_query_rate": recent_rate,
+            "earlier_query_rate": earlier_rate,
+            "trend": "decreasing" if recent_rate < earlier_rate else "increasing" if recent_rate > earlier_rate else "stable",
+        }
+
+
+# ═══════════════════════════════════════════════════════════
+# MAIN / TEST
+# ═══════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    lib = KnowledgeLibrary()
+    lib.load()
+    print(f"Knowledge Library: {lib.stats()}")
+
+    # Test queries
+    test_queries = [
+        "how do I handle file I/O errors in Python?",
+        "what is the format for writing a file with the fs tool?",
+        "how do I prevent SQL injection?",
+        "what is list comprehension syntax?",
+        "how does pytest discover tests?",
+    ]
+
+    for q in test_queries:
+        print(f"\n  Query: {q}")
+        results = lib.query(q, top_k=2)
+        for r in results:
+            content_preview = r["content"][:120].replace("\n", " ")
+            print(f"    [{r['score']}] {r['topic']}: {content_preview}...")