intentmind 0.1.0__py3-none-any.whl

intentmind/__init__.py

@@ -0,0 +1,3 @@
+from .runtime import IntentmindMemory
+
+__all__ = ["IntentmindMemory"]

intentmind/benchmark/__init__.py

@@ -0,0 +1,3 @@
+from .runner import BenchmarkRunner
+
+__all__ = ["BenchmarkRunner"]

intentmind/benchmark/runner.py

@@ -0,0 +1,345 @@
+import time
+from math import ceil
+from typing import List, Dict, Any
+from ..runtime import IntentmindMemory
+from ..embeddings import cosine_similarity
+
+class BenchmarkRunner:
+    def __init__(self, memory: IntentmindMemory):
+        self.memory = memory
+
+    def classic_rag_search(self, query: str, top_k: int = 5) -> List[Dict]:
+        """Simulates a classic vector search RAG without Intentmind features."""
+        query_emb = self.memory.embedder.embed(query)
+        results = []
+        for chunk in self.memory._store.chunks.values():
+            sim = cosine_similarity(query_emb, chunk.embedding)
+            results.append({"chunk_id": chunk.chunk_id, "score": sim, "text": chunk.text})
+        
+        results.sort(key=lambda x: x["score"], reverse=True)
+        return results[:top_k]
+
+    def evaluate_query(
+        self,
+        query: str,
+        expected_chunks: List[str],
+        expected_intents: List[str] = None,
+        expected_reason: str | None = None,
+        top_k: int = 5,
+    ) -> Dict[str, Any]:
+        """Evaluates a single query against both Classic RAG and Intentmind."""
+        
+        # 1. Classic RAG
+        start_time = time.perf_counter()
+        rag_results = self.classic_rag_search(query, top_k=top_k)
+        rag_latency = time.perf_counter() - start_time
+        
+        rag_retrieved_ids = [r["chunk_id"] for r in rag_results]
+        rag_tokens = sum(len(r["text"].split()) for r in rag_results)
+
+        # 2. Intentmind
+        start_time = time.perf_counter()
+        im_results = self.memory.query(query)
+        im_latency = time.perf_counter() - start_time
+        
+        im_items = im_results["memories"]["items"]
+        im_retrieved_ids = [item["chunk_id"] for item in im_items]
+        im_tokens = sum(len(item["text"].split()) for item in im_items)
+        
+        # Calculate Metrics
+        expected_set = set(expected_chunks)
+        
+        rag_precision, rag_recall = self._precision_recall(rag_retrieved_ids, expected_set)
+        im_precision, im_recall = self._precision_recall(im_retrieved_ids, expected_set)
+        rag_f1 = self._f1(rag_precision, rag_recall)
+        im_f1 = self._f1(im_precision, im_recall)
+        
+        # Token Saving (lower is better, but saving % is higher = better)
+        token_saving = 0.0
+        if rag_tokens > 0:
+            token_saving = (rag_tokens - im_tokens) / rag_tokens
+
+        return {
+            "query": query,
+            "expected_chunks": expected_chunks,
+            "classic_rag": {
+                "latency_ms": round(rag_latency * 1000, 2),
+                "precision": round(rag_precision, 3),
+                "recall": round(rag_recall, 3),
+                "f1": round(rag_f1, 3),
+                "hit_at_k": self._hit_at_k(rag_retrieved_ids, expected_set, top_k),
+                "mrr": round(self._mrr(rag_retrieved_ids, expected_set), 3),
+                "retrieved_count": len(rag_retrieved_ids),
+                "tokens": rag_tokens,
+                "false_positives": [cid for cid in rag_retrieved_ids if cid not in expected_set],
+                "false_negatives": [cid for cid in expected_chunks if cid not in set(rag_retrieved_ids)],
+                "retrieved": [
+                    {
+                        "rank": idx + 1,
+                        "chunk_id": item["chunk_id"],
+                        "score": round(item["score"], 4),
+                        "text": item["text"],
+                    }
+                    for idx, item in enumerate(rag_results)
+                ],
+            },
+            "intentmind": {
+                "latency_ms": round(im_latency * 1000, 2),
+                "latency_breakdown": im_results.get("latency_breakdown", {}),
+                "precision": round(im_precision, 3),
+                "recall": round(im_recall, 3),
+                "f1": round(im_f1, 3),
+                "hit_at_k": self._hit_at_k(im_retrieved_ids, expected_set, top_k),
+                "mrr": round(self._mrr(im_retrieved_ids, expected_set), 3),
+                "retrieved_count": len(im_retrieved_ids),
+                "tokens": im_tokens,
+                "token_saving_pct": round(token_saving * 100, 2),
+                "rejected_count": im_results["memories"]["rejected"],
+                "false_positives": [cid for cid in im_retrieved_ids if cid not in expected_set],
+                "false_negatives": [cid for cid in expected_chunks if cid not in set(im_retrieved_ids)],
+                "direct_count": im_results["memories"]["direct"],
+                "associated_count": im_results["memories"]["associated"],
+                "weak_echo_count": im_results["memories"]["weak_echo"],
+                "retrieved": [
+                    {
+                        "rank": idx + 1,
+                        "chunk_id": item["chunk_id"],
+                        "score": round(item["score"], 4),
+                        "layer": item["layer"],
+                        "intent": item["intent"],
+                        "called_by": item.get("called_by"),
+                        "reason": item.get("reason"),
+                        "path": item.get("path", []),
+                        "edge": item.get("edge", {}),
+                        "text": item["text"],
+                    }
+                    for idx, item in enumerate(im_items)
+                ],
+                "trace": im_results.get("trace", []),
+            },
+            "analysis": {
+                "expected_intents": expected_intents or [],
+                "expected_reason": expected_reason or "",
+                "intentmind_paths": [
+                    item.get("path", [])
+                    for item in im_items
+                    if item.get("path")
+                ],
+            },
+        }
+
+    def run_suite(self, queries: List[Dict], top_k: int = 5) -> Dict[str, Any]:
+        """Runs the benchmark on a list of test cases."""
+        results = []
+        for q_data in queries:
+            res = self.evaluate_query(
+                query=q_data["query"],
+                expected_chunks=q_data["expected_chunks"],
+                expected_intents=q_data.get("expected_intents", []),
+                expected_reason=q_data.get("expected_reason"),
+                top_k=top_k,
+            )
+            results.append(res)
+            
+        # Aggregate
+        def avg(key1, key2):
+            return sum(r[key1][key2] for r in results) / len(results)
+
+        # Aggregate latency breakdown
+        breakdown_keys = ["embed_query_ms", "emotion_ms", "extractor_ms", "recall_ms", "prompt_ms"]
+        def breakdown_avg(key):
+            vals = [r["intentmind"].get("latency_breakdown", {}).get(key, 0.0) for r in results]
+            return round(sum(vals) / len(vals), 2) if vals else 0.0
+
+        summary = {
+            "total_queries": len(queries),
+            "top_k": top_k,
+            "classic_rag_avg_precision": round(avg("classic_rag", "precision"), 3),
+            "classic_rag_avg_recall": round(avg("classic_rag", "recall"), 3),
+            "classic_rag_avg_f1": round(avg("classic_rag", "f1"), 3),
+            "classic_rag_avg_hit_at_k": round(avg("classic_rag", "hit_at_k"), 3),
+            "classic_rag_avg_mrr": round(avg("classic_rag", "mrr"), 3),
+            "classic_rag_avg_latency_ms": round(avg("classic_rag", "latency_ms"), 3),
+            "classic_rag_p50_latency_ms": self._percentile([r["classic_rag"]["latency_ms"] for r in results], 50),
+            "classic_rag_p95_latency_ms": self._percentile([r["classic_rag"]["latency_ms"] for r in results], 95),
+            "classic_rag_avg_tokens": round(avg("classic_rag", "tokens"), 3),
+            "intentmind_avg_precision": round(avg("intentmind", "precision"), 3),
+            "intentmind_avg_recall": round(avg("intentmind", "recall"), 3),
+            "intentmind_avg_f1": round(avg("intentmind", "f1"), 3),
+            "intentmind_avg_hit_at_k": round(avg("intentmind", "hit_at_k"), 3),
+            "intentmind_avg_mrr": round(avg("intentmind", "mrr"), 3),
+            "intentmind_avg_latency_ms": round(avg("intentmind", "latency_ms"), 3),
+            "intentmind_p50_latency_ms": self._percentile([r["intentmind"]["latency_ms"] for r in results], 50),
+            "intentmind_p95_latency_ms": self._percentile([r["intentmind"]["latency_ms"] for r in results], 95),
+            "intentmind_avg_tokens": round(avg("intentmind", "tokens"), 3),
+            "intentmind_avg_token_saving_pct": round(avg("intentmind", "token_saving_pct"), 3),
+            "intentmind_avg_direct_count": round(avg("intentmind", "direct_count"), 3),
+            "intentmind_avg_associated_count": round(avg("intentmind", "associated_count"), 3),
+            "intentmind_latency_breakdown": {k: breakdown_avg(k) for k in breakdown_keys},
+        }
+        
+        return {
+            "summary": summary,
+            "details": results
+        }
+
+    def generate_markdown_report(self, results: Dict[str, Any], title: str = "Real World Benchmark Report") -> str:
+        summary = results["summary"]
+        details = results["details"]
+        wins = [
+            item for item in details
+            if item["intentmind"]["f1"] > item["classic_rag"]["f1"]
+        ]
+        losses = [
+            item for item in details
+            if item["intentmind"]["f1"] < item["classic_rag"]["f1"]
+        ]
+        ties = len(details) - len(wins) - len(losses)
+
+        lines = [
+            f"# {title}",
+            "",
+            "This report compares the same memory corpus with classic vector RAG and Intentmind.",
+            "The goal is not to claim universal superiority, but to show where associative recall helps, where it fails, and why.",
+            "",
+            "## Summary",
+            "",
+            f"- Total queries: {summary['total_queries']}",
+            f"- Top-K baseline: {summary['top_k']}",
+            f"- Intentmind wins/ties/losses by F1: {len(wins)} / {ties} / {len(losses)}",
+            "",
+            "| System | Precision | Recall | F1 | Hit@K | MRR | Avg Tokens | p50 Latency | p95 Latency |",
+            "|---|---:|---:|---:|---:|---:|---:|---:|---:|",
+            (
+                f"| Classic RAG | {summary['classic_rag_avg_precision']} | "
+                f"{summary['classic_rag_avg_recall']} | {summary['classic_rag_avg_f1']} | "
+                f"{summary['classic_rag_avg_hit_at_k']} | {summary['classic_rag_avg_mrr']} | "
+                f"{summary['classic_rag_avg_tokens']} | {summary['classic_rag_p50_latency_ms']} ms | "
+                f"{summary['classic_rag_p95_latency_ms']} ms |"
+            ),
+            (
+                f"| Intentmind | {summary['intentmind_avg_precision']} | "
+                f"{summary['intentmind_avg_recall']} | {summary['intentmind_avg_f1']} | "
+                f"{summary['intentmind_avg_hit_at_k']} | {summary['intentmind_avg_mrr']} | "
+                f"{summary['intentmind_avg_tokens']} | {summary['intentmind_p50_latency_ms']} ms | "
+                f"{summary['intentmind_p95_latency_ms']} ms |"
+            ),
+            "",
+            f"Average token saving: {summary['intentmind_avg_token_saving_pct']}%",
+            f"Average direct/associated memories: {summary['intentmind_avg_direct_count']} / {summary['intentmind_avg_associated_count']}",
+            "",
+            "## Intentmind Latency Breakdown (avg ms)",
+            "",
+            "| Phase | Avg ms | Description |",
+            "|---|---:|---|",
+        ]
+
+        lb = summary.get("intentmind_latency_breakdown", {})
+        phase_desc = {
+            "embed_query_ms": "Query embedding (SentenceTransformer or equivalent)",
+            "emotion_ms": "Emotion detection",
+            "extractor_ms": "Intent extraction (fixture / LLM)",
+            "recall_ms": "Graph traversal + chunk scoring",
+            "prompt_ms": "Prompt assembly",
+        }
+        for key in ["embed_query_ms", "emotion_ms", "extractor_ms", "recall_ms", "prompt_ms"]:
+            desc = phase_desc.get(key, key)
+            val = lb.get(key, 0.0)
+            lines.append(f"| {key.replace('_ms', '')} | {val} | {desc} |")
+        lines.extend([
+            "",
+            f"> **Note:** The extractor phase uses a fixture-backed dictionary lookup in this benchmark (<1ms). "
+            f"With a real LLM extractor (e.g. GPT-4o-mini), this phase would add 200–800ms per query.",
+            "",
+            "## Why This Can Be Better Than Classic RAG",
+            "",
+            "Classic RAG retrieves chunks by query-to-chunk vector similarity. Intentmind first activates query intents, then traverses graph neighbors and scores linked chunks.",
+            "This matters when the query does not repeat the exact missing concept, but touches an associated concept that was observed with it before.",
+            "",
+            "## Representative Associative Cases",
+            "",
+        ])
+
+        associative_cases = [
+            item for item in details
+            if any(result.get("layer", 0) > 0 for result in item["intentmind"]["retrieved"])
+        ][:8]
+        if not associative_cases:
+            lines.append("No associated-memory cases were returned in this run.")
+        for item in associative_cases:
+            lines.extend(self._case_lines(item))
+
+        lines.extend(["", "## Failure Or Risk Cases", ""])
+        risky = [
+            item for item in details
+            if item["intentmind"]["false_negatives"] or item["intentmind"]["false_positives"]
+        ][:8]
+        if not risky:
+            lines.append("No Intentmind false positives or false negatives were observed in this run.")
+        for item in risky:
+            lines.extend(self._case_lines(item))
+
+        lines.extend([
+            "",
+            "## Methodology Notes",
+            "",
+            "- Both systems use the same corpus and same embedder.",
+            "- Classic RAG uses vector top-k chunk retrieval.",
+            "- Intentmind uses faithful fixture extraction in this benchmark so recall dynamics are deterministic.",
+            "- Public claims require larger datasets, independent ground truth, and repeated runs with median/p95 reporting.",
+        ])
+        return "\n".join(lines) + "\n"
+
+    def _case_lines(self, item: Dict[str, Any]) -> List[str]:
+        expected = ", ".join(item["expected_chunks"]) or "(none)"
+        rag = ", ".join(r["chunk_id"] for r in item["classic_rag"]["retrieved"]) or "(none)"
+        im = ", ".join(
+            f"{r['chunk_id']}[{r.get('reason')}:{' > '.join(r.get('path', []))}]"
+            for r in item["intentmind"]["retrieved"]
+        ) or "(none)"
+        reason = item["analysis"].get("expected_reason") or "No explicit reason provided."
+        return [
+            f"### {item['query']}",
+            "",
+            f"- Expected chunks: {expected}",
+            f"- Classic RAG: {rag}",
+            f"- Intentmind: {im}",
+            f"- Expected reason: {reason}",
+            "",
+        ]
+
+    def _precision_recall(self, retrieved: List[str], expected: set) -> tuple[float, float]:
+        if not expected:
+            return (1.0, 1.0) if not retrieved else (0.0, 1.0)
+        if not retrieved:
+            return 0.0, 0.0
+        hits = len(set(retrieved).intersection(expected))
+        precision = hits / len(retrieved)
+        recall = hits / len(expected)
+        return precision, recall
+
+    def _f1(self, precision: float, recall: float) -> float:
+        if precision + recall == 0:
+            return 0.0
+        return 2 * precision * recall / (precision + recall)
+
+    def _hit_at_k(self, retrieved: List[str], expected: set, top_k: int) -> int:
+        if not expected:
+            return 1 if not retrieved else 0
+        return 1 if set(retrieved[:top_k]).intersection(expected) else 0
+
+    def _mrr(self, retrieved: List[str], expected: set) -> float:
+        if not expected:
+            return 1.0 if not retrieved else 0.0
+        for idx, chunk_id in enumerate(retrieved):
+            if chunk_id in expected:
+                return 1.0 / (idx + 1)
+        return 0.0
+
+    def _percentile(self, values: List[float], percentile: int) -> float:
+        if not values:
+            return 0.0
+        ordered = sorted(values)
+        rank = ceil((percentile / 100) * len(ordered)) - 1
+        rank = max(0, min(rank, len(ordered) - 1))
+        return round(ordered[rank], 3)

intentmind/benchmark/utils.py

@@ -0,0 +1,55 @@
+import json
+from typing import Any, Callable, Dict
+
+
+def load_fixture(json_path: str) -> Dict[str, Any]:
+    with open(json_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def build_fixture_extractor(data: Dict[str, Any]) -> Callable[[str], list[str]]:
+    """
+    Build a deterministic stand-in for a faithful LLM extractor.
+
+    This is for benchmark repeatability. It lets us evaluate graph/recall
+    behavior without depending on live LLM calls or hand-tuned FakeEmbedder
+    vocabulary.
+    """
+    by_text = {}
+    for item in data.get("memories", []):
+        intents = item.get("intents", [])
+        if intents:
+            by_text[item["text"]] = intents
+    for item in data.get("queries", []):
+        intents = item.get("expected_intents", [])
+        if intents:
+            by_text[item["query"]] = intents
+
+    def extractor(text: str) -> list[str]:
+        return list(by_text.get(text, []))
+
+    return extractor
+
+def load_fixture_and_map(memory_instance, json_path: str) -> Dict[str, Any]:
+    """
+    Loads a benchmark fixture JSON, ingests memories into the provided IntentmindMemory instance,
+    and returns the mapped queries taking automatic deduplication into account.
+    """
+    data = load_fixture(json_path)
+
+    chunk_mapping = {}
+    for item in data.get("memories", []):
+        surviving_id = memory_instance.add(
+            text=item["text"], 
+            source="benchmark", 
+            chunk_id=item["chunk_id"]
+        )
+        chunk_mapping[item["chunk_id"]] = surviving_id
+
+    # Update expected queries based on merges
+    for q in data.get("queries", []):
+        if "expected_chunks" in q:
+            mapped = set(chunk_mapping.get(cid, cid) for cid in q["expected_chunks"])
+            q["expected_chunks"] = list(mapped)
+            
+    return data

intentmind/builders/__init__.py

@@ -0,0 +1,2 @@
+from .prompt_builder import PromptBuilder
+__all__ = ["PromptBuilder"]

intentmind/builders/prompt_builder.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+
+class PromptBuilder:
+    def __init__(self, max_chars: int = 60000):
+        self.max_chars = max_chars
+
+    def build(self, user_query, recall_result, emotional_state):
+        system_block = (
+            "[SYSTEM]\n"
+            "You are a memory-augmented assistant.\n"
+            "Use memories only as supporting context.\n"
+            "Prioritize the user's latest message.\n"
+            "Do not over-generalize or give medical disclaimers unless necessary.\n"
+            "Respond naturally and directly.\n"
+        )
+        
+        user_block = f"[USER_MESSAGE]\n{user_query}\n"
+        
+        context_block = self._build_context_block(recall_result, emotional_state)
+        field_block = self._build_field_block(recall_result)
+        memory_block = self._build_memory_block(recall_result)
+        style_block = self._build_style_block(emotional_state)
+        
+        prompt = f"{system_block}\n{user_block}\n{context_block}\n{field_block}\n{memory_block}\n{style_block}".strip()
+        
+        if len(prompt) <= self.max_chars:
+            return prompt
+        return prompt[: self.max_chars] + "\n\n[TRIMMED]\nPrompt budget exceeded."
+
+    def _build_context_block(self, recall_result, emotional_state):
+        lines = ["[CURRENT_CONTEXT]"]
+        
+        # Collect top active intents from layers 0 and 1, unique and sorted by score
+        intents = {}
+        for layer_id in [0, 1]:
+            for item in recall_result.get("activated_layers", {}).get(layer_id, []):
+                label = item["intent"].label
+                if label not in intents or item["score"] > intents[label]:
+                    intents[label] = item["score"]
+        
+        if intents:
+            top_intents = sorted(intents.items(), key=lambda x: x[1], reverse=True)[:5]
+            lines.append("Primary topics:")
+            for label, _ in top_intents:
+                lines.append(f"- {label}")
+        else:
+            lines.append("Primary topics: None")
+            
+        lines.append(f"\nEmotional state:\n- {emotional_state.current}")
+        return "\n".join(lines) + "\n"
+
+    def _build_field_block(self, recall_result):
+        field = recall_result.get("cognitive_field") or {}
+        lines = ["[COGNITIVE FIELD]"]
+
+        seeds = field.get("seed_intents", [])
+        activated = field.get("activated_intents", [])
+
+        if seeds:
+            seed_labels = [item.get("label", "") for item in seeds if item.get("label")]
+            lines.append("Seeds: " + ", ".join(seed_labels[:8]))
+        else:
+            lines.append("Seeds: None")
+
+        resonant = [
+            item for item in activated
+            if item.get("role") != "seed" and item.get("label")
+        ]
+        if resonant:
+            labels = [f"{item['label']}({item.get('energy', 0.0)})" for item in resonant[:8]]
+            lines.append("Resonant: " + ", ".join(labels))
+        else:
+            lines.append("Resonant: None")
+
+        return "\n".join(lines) + "\n"
+
+    def _build_memory_block(self, recall_result):
+        lines = ["[RELEVANT_MEMORIES]"]
+        memories = []
+        
+        for bucket in ["direct_memories", "associated_memories", "weak_echo_memories"]:
+            for item in recall_result.get(bucket, []):
+                memories.append(item)
+                
+        # Sort by score and take top 30 (to rely on threshold logic instead of hard caps)
+        memories = sorted(memories, key=lambda x: x["score"], reverse=True)[:30]
+        
+        if not memories:
+            lines.append("No relevant memories found.")
+        else:
+            for i, item in enumerate(memories, 1):
+                text = self.compress(item["chunk"].text) # changed from summary to text
+                score = round(item["score"], 2)
+                lines.append(f"{i}. \"{text}\"")
+                lines.append(f"relevance: {score}\n")
+                
+        return "\n".join(lines)
+
+    def _build_style_block(self, emotional_state):
+        lines = ["[RESPONSE_STYLE]"]
+        lines.append("- short")
+        lines.append("- grounded")
+        lines.append("- conversational")
+        lines.append("- avoid generic assistant phrasing")
+        
+        modes = {
+            "nötr": "- balanced and informative",
+            "merak": "- highlight possibilities and connections",
+            "heyecan": "- open to new creative ideas",
+            "güven": "- confident and deep",
+            "şüphe": "- rely strictly on reliable memory",
+            "korku": "- safe, concise, and clear",
+        }
+        lines.append(modes.get(emotional_state.current, modes["nötr"]))
+        return "\n".join(lines)
+
+    def compress(self, text: str, max_len: int = 5000) -> str:
+        text = " ".join(text.split())
+        if len(text) <= max_len:
+            return text
+        return text[: max_len - 3] + "..."

intentmind/embeddings/__init__.py

@@ -0,0 +1,8 @@
+from .base import BaseEmbedder
+from .fake import FakeEmbedder, cosine_similarity
+try:
+    from .sentence_transformer import SentenceTransformerEmbedder
+except Exception:  # optional dependency
+    SentenceTransformerEmbedder = None
+
+__all__ = ["BaseEmbedder", "FakeEmbedder", "SentenceTransformerEmbedder", "cosine_similarity"]

intentmind/embeddings/base.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class BaseEmbedder(ABC):
+    name: str = "base"
+
+    @abstractmethod
+    def embed(self, text: str) -> List[float]:
+        raise NotImplementedError

intentmind/embeddings/fake.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import math
+import random
+from typing import List
+from .base import BaseEmbedder
+
+SEMANTIC_GROUPS = {
+    "memory":    ["hafıza", "memory", "recall", "chunk", "store", "geçmiş"],
+    "graph":     ["graph", "intent", "edge", "node", "traversal", "layer", "bağ"],
+    "energy":    ["energy", "enerji", "decay", "zayıflama", "güçlenme", "stability"],
+    "emotion":   ["emotion", "duygu", "emotional", "merak", "heyecan", "şüphe", "korku"],
+    "score":     ["score", "activation", "similarity", "threshold", "weight", "ağırlık"],
+    "prompt":    ["prompt", "builder", "context", "bağlam", "llm", "cevap"],
+    "pruning":   ["pruning", "budama", "temizleme", "pollution", "explosion", "duplicate"],
+    "car":       ["car", "araba", "arabayla", "arabanın", "arabanin", "arabam", "arabayi", "servis", "servise"],
+    "insurance": ["insurance", "sigorta", "sigortasini"],
+    "money":     ["money", "para", "param"],
+    "travel":    ["london", "antalya", "antalyaya", "yolculuk", "istanbul", "istanbula", "goturecegim", "gitmem", "yarin", "gidecegim"],
+    "fuel":      ["benzin", "benzini", "bitti"],
+    "food":      ["food", "meal", "yemek", "yemistik"],
+}
+
+DIM = 32
+
+
+def _group_vector(group_idx: int, dim: int = DIM) -> List[float]:
+    vec = [0.0] * dim
+    width = max(1, dim // len(SEMANTIC_GROUPS))
+    start = group_idx * width
+    end = start + width
+    for i in range(start, min(end, dim)):
+        vec[i] = 1.0
+    return vec
+
+
+GROUP_VECTORS = {group: _group_vector(idx) for idx, group in enumerate(SEMANTIC_GROUPS)}
+
+
+def cosine_similarity(a: List[float], b: List[float]) -> float:
+    dot = sum(x * y for x, y in zip(a, b))
+    norm_a = math.sqrt(sum(x * x for x in a))
+    norm_b = math.sqrt(sum(x * x for x in b))
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+    return dot / (norm_a * norm_b)
+
+
+class FakeEmbedder(BaseEmbedder):
+    name = "fake-semantic-cluster"
+
+    def __init__(self, dim: int = DIM):
+        self.dim = dim
+
+    def embed(self, text: str) -> List[float]:
+        text_l = text.lower()
+        group_weights = {}
+        for group, keywords in SEMANTIC_GROUPS.items():
+            hits = sum(1 for kw in keywords if kw in text_l)
+            if hits > 0:
+                group_weights[group] = hits
+
+        import hashlib
+        seed_int = int(hashlib.sha256(text.encode("utf-8")).hexdigest()[:8], 16)
+        random.seed(seed_int)
+        vec = [random.gauss(0, 0.15) for _ in range(self.dim)]
+
+        if group_weights:
+            total = sum(group_weights.values())
+            for group, w in group_weights.items():
+                gv = GROUP_VECTORS[group]
+                alpha = (w / total) * 2.0
+                for i in range(min(self.dim, len(gv))):
+                    vec[i] += alpha * gv[i]
+
+        norm = math.sqrt(sum(x * x for x in vec))
+        if norm == 0:
+            return [1.0 / math.sqrt(self.dim)] * self.dim
+        return [x / norm for x in vec]

intentmind/embeddings/sentence_transformer.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import List
+from .base import BaseEmbedder
+
+
+class SentenceTransformerEmbedder(BaseEmbedder):
+    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2"):
+        try:
+            from sentence_transformers import SentenceTransformer
+        except ImportError as exc:
+            raise ImportError(
+                "sentence-transformers yüklü değil. Kurulum: pip install sentence-transformers"
+            ) from exc
+        self.model_name = model_name
+        self.name = model_name
+        self._model = SentenceTransformer(model_name)
+
+    def embed(self, text: str) -> List[float]:
+        return self._model.encode(text, normalize_embeddings=True).tolist()

intentmind/engines/__init__.py

@@ -0,0 +1,5 @@
+from .intent_engine import IntentEngine
+from .emotion_engine import EmotionEngine
+from .recall_engine import RecallEngine
+from .energy_engine import EnergyEngine
+__all__ = ["IntentEngine", "EmotionEngine", "RecallEngine", "EnergyEngine"]