lorien-memory 0.2.0__py3-none-any.whl

lorien/__init__.py

@@ -0,0 +1,17 @@
+from .contradiction import ContradictionDetector
+from .ingest import LorienIngester
+from .memory import LorienMemory
+from .models import Entity, Fact, Rule
+from .query import KnowledgeGraph
+from .schema import GraphStore
+
+__all__ = [
+    "ContradictionDetector",
+    "Entity",
+    "Fact",
+    "Rule",
+    "GraphStore",
+    "KnowledgeGraph",
+    "LorienIngester",
+    "LorienMemory",
+]

lorien/cli.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from .query import KnowledgeGraph
+from .schema import GraphStore
+
+DEFAULT_DB = "~/.lorien/db"
+
+
+@click.group()
+def main() -> None:
+    """lorien — local-first personal knowledge graph for AI agents."""
+
+
+@main.command()
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+def init(db: str) -> None:
+    """Initialize a new lorien graph store."""
+    store = GraphStore(db_path=db)
+    counts = store.count_nodes()
+    click.echo(f"✓ lorien initialized at {Path(db).expanduser()}")
+    click.echo(f"  {counts}")
+
+
+@main.command()
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+def status(db: str) -> None:
+    """Show node counts."""
+    store = GraphStore(db_path=db)
+    for name, count in store.count_nodes().items():
+        click.echo(f"  {name}: {count}")
+
+
+@main.command()
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+@click.option("--model", default=None, help="LLM model e.g. claude-haiku-3-5 (enables LLM extraction)")
+@click.option("--api-key", default=None, envvar=["ANTHROPIC_API_KEY", "LORIEN_API_KEY"],
+              help="API key (reads ANTHROPIC_API_KEY or LORIEN_API_KEY from env)")
+@click.option("--base-url", default=None, envvar="LORIEN_LLM_BASE_URL")
+@click.option("--verbose", "-v", is_flag=True, default=False)
+@click.option("--batch", default=1, show_default=True,
+              help="Sections per LLM call (>1 reduces API calls, use 3-5)")
+def ingest(
+    file: str, db: str, model: str | None, api_key: str | None,
+    base_url: str | None, verbose: bool, batch: int
+) -> None:
+    """Ingest a text or MEMORY.md file.
+
+    With --model: uses LLM for rich entity extraction.
+    Without --model: keyword fallback (rules only).
+
+    Example:
+      lorien ingest MEMORY.md --model haiku --batch 4
+    """
+    from .ingest import LorienIngester
+
+    # Let LorienIngester auto-detect OpenClaw gateway; only fail if explicitly needed
+    if model and not api_key:
+        from .ingest import _read_openclaw_gateway
+        if not _read_openclaw_gateway():
+            click.echo("⚠ --model set but no API key found (set ANTHROPIC_API_KEY or configure OpenClaw gateway)", err=True)
+            sys.exit(1)
+        if verbose:
+            click.echo("→ Using OpenClaw gateway")
+
+    store = GraphStore(db_path=db)
+    ingester = LorienIngester(store, llm_model=model, api_key=api_key, base_url=base_url)
+
+    if verbose and model:
+        click.echo(f"→ LLM mode: {model}")
+
+    filename = Path(file).name
+    if filename.upper().startswith("MEMORY") and file.endswith(".md"):
+        result = ingester.ingest_memory_md(file, verbose=verbose, batch_size=batch)
+    else:
+        text = Path(file).read_text(encoding="utf-8")
+        result = ingester.ingest_text(text, source=file)
+
+    click.echo(
+        f"✓ {file}: +{result.entities_added} entities, +{result.facts_added} facts, +{result.rules_added} rules"
+    )
+    if result.errors:
+        for error in result.errors[:5]:
+            click.echo(f"  ⚠ {error}", err=True)
+
+
+@main.command()
+@click.argument("cypher")
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+def query(cypher: str, db: str) -> None:
+    """Run raw Cypher query."""
+    store = GraphStore(db_path=db)
+    for row in store.query(cypher):
+        click.echo(row)
+
+
+@main.command()
+@click.argument("entity_name")
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+def show(entity_name: str, db: str) -> None:
+    """Show all context for an entity."""
+    store = GraphStore(db_path=db)
+    graph = KnowledgeGraph(store)
+    entity = graph.get_entity(entity_name)
+    if not entity:
+        click.echo(f"Not found: {entity_name}", err=True)
+        sys.exit(1)
+    context = graph.get_entity_context(entity["id"])
+    click.echo(f"\n{entity['name']} ({entity['entity_type']})")
+    click.echo("─" * 40)
+    for fact in context["facts"]:
+        click.echo(f"  • {fact['text']}  [{fact['confidence']:.2f}]")
+    for rule in context["rules"]:
+        click.echo(f"  ★ [{rule['rule_type']}] {rule['text']}")
+
+
+@main.command()
+@click.option("--to-md", required=True, type=click.Path())
+@click.option("--entity", default=None)
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+def sync(to_md: str, entity: str | None, db: str) -> None:
+    """Export graph to MEMORY.md-style file."""
+    store = GraphStore(db_path=db)
+    graph = KnowledgeGraph(store)
+    markdown = graph.export_to_memory_md(entity_name=entity)
+    Path(to_md).write_text(markdown, encoding="utf-8")
+    click.echo(f"✓ Exported to {to_md}")
+
+
+@main.command()
+@click.argument("user_id")
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+@click.option("--model", default=None, help="LLM model for extraction")
+@click.option("--api-key", default=None, envvar=["ANTHROPIC_API_KEY", "LORIEN_API_KEY"])
+@click.option("--limit", default=20, show_default=True)
+def memory(user_id: str, db: str, model: str | None, api_key: str | None, limit: int) -> None:
+    """Show all memories for USER_ID, or pipe a conversation for real-time ingestion.
+
+    Show memories:
+      lorien memory 아부지
+
+    Add from stdin (JSON messages):
+      echo '[{"role":"user","content":"나는 커피를 싫어해"}]' | lorien memory 아부지 --model haiku
+    """
+    import select
+
+    from .memory import LorienMemory
+
+    mem = LorienMemory(db_path=db, model=model, api_key=api_key)
+
+    # Check if stdin has data (piped input)
+    if select.select([sys.stdin], [], [], 0.0)[0]:
+        import json as _json
+        raw = sys.stdin.read().strip()
+        try:
+            messages = _json.loads(raw)
+        except Exception:
+            click.echo("⚠ stdin must be JSON array of {role, content} objects", err=True)
+            sys.exit(1)
+        result = mem.add(messages, user_id=user_id)
+        click.echo(f"✓ +{result['entities']} entities, +{result['facts']} facts, +{result['rules']} rules")
+    else:
+        # Show all memories
+        memories = mem.get_all(user_id=user_id, limit=limit)
+        if not memories:
+            click.echo(f"No memories for {user_id}")
+            return
+        click.echo(f"\n{user_id} — {len(memories)} memories")
+        click.echo("─" * 40)
+        for m in memories:
+            prefix = "★" if m["type"] == "rule" else "•"
+            extra = f" [p{m.get('priority', '')}]" if m["type"] == "rule" else f" [{m['score']:.2f}]"
+            click.echo(f"  {prefix} {m['memory']}{extra}")
+
+
+@main.command()
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+@click.option("--port", default=7331, show_default=True)
+def serve(db: str, port: int) -> None:
+    """Launch local web graph viewer at http://127.0.0.1:PORT."""
+    from .serve import serve as _serve
+    _serve(db_path=db, port=port)
+
+
+@main.command()
+@click.option("--db", default=DEFAULT_DB, show_default=True)
+def contradictions(db: str) -> None:
+    """List all detected contradictions."""
+    store = GraphStore(db_path=db)
+    graph = KnowledgeGraph(store)
+    items = graph.find_contradictions()
+    if not items:
+        click.echo("✓ No contradictions.")
+        return
+    click.echo(f"⚠️  {len(items)} contradiction(s):")
+    for item in items:
+        click.echo(f"\n  A: {item['fact_a']['text']}")
+        click.echo(f"  B: {item['fact_b']['text']}")

lorien/contradiction.py

@@ -0,0 +1,179 @@
+"""ContradictionDetector — automatic contradiction detection using vector similarity + LLM."""
+from __future__ import annotations
+
+import json
+import re
+import urllib.request
+from typing import Optional
+
+from .schema import GraphStore
+
+CONTRADICTION_PROMPT = """Do these two statements DIRECTLY CONTRADICT each other?
+Answer ONLY 'yes' or 'no'.
+
+Statement A: {a}
+Statement B: {b}"""
+
+
+class ContradictionDetector:
+    """Detects contradictions between new facts/rules and existing ones.
+
+    Uses vector similarity to find candidates, then LLM to confirm.
+    Falls back to heuristic-only (negation patterns) if no LLM configured.
+    """
+
+    # Negation pairs — offline heuristic
+    NEGATION_PAIRS = [
+        ("좋아", "싫어"),
+        ("좋아해", "싫어해"),
+        ("좋다", "싫다"),
+        ("허용", "금지"),
+        ("허용한다", "금지한다"),
+        ("가능", "불가능"),
+        ("해야", "하지 말"),
+        ("반드시", "절대"),
+        ("always", "never"),
+        ("must", "must not"),
+        ("allow", "prohibit"),
+        ("enable", "disable"),
+        ("할 수 있다", "할 수 없다"),
+    ]
+
+    def __init__(
+        self,
+        store: GraphStore,
+        vector_index=None,  # VectorIndex | None
+        llm_model: str | None = None,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        use_openclaw: bool = False,
+        similarity_threshold: float = 0.55,
+    ) -> None:
+        self.store = store
+        self.vectors = vector_index
+        self.llm_model = llm_model
+        self.api_key = api_key
+        self.base_url = base_url or "https://api.openai.com/v1"
+        self._use_openclaw = use_openclaw
+        self.threshold = similarity_threshold
+
+    def check_and_record(self, new_node_id: str, new_text: str, node_type: str = "Fact") -> int:
+        """Check if new_text contradicts existing facts/rules. Returns number of contradictions found.
+
+        Creates CONTRADICTS edges for confirmed contradictions.
+        """
+        if not new_text or not new_text.strip():
+            return 0
+
+        # Find candidates via vector similarity
+        candidates = []
+        if self.vectors:
+            similar = self.vectors.search(
+                new_text,
+                top_k=8,
+                node_type=node_type,
+                threshold=self.threshold,
+                exclude_ids={new_node_id},
+            )
+            candidates = similar
+        else:
+            # No vector index: heuristic only on recent facts
+            rows = self.store.query(
+                f"MATCH (n:{node_type}) WHERE n.status = 'active' AND n.id <> '{new_node_id}' "
+                f"RETURN n.id, n.text LIMIT 50"
+            )
+            for nid, text in rows:
+                if self._heuristic_contradiction(new_text, text):
+                    candidates.append({"id": nid, "text": text, "score": 0.8})
+
+        found = 0
+        for candidate in candidates:
+            cid = candidate["id"]
+            ctext = candidate["text"]
+            if self._is_contradiction(new_text, ctext):
+                try:
+                    if node_type == "Fact":
+                        self.store.add_contradicts(new_node_id, cid)
+                    # For Rules: store as Fact contradiction if both are Facts
+                    found += 1
+                except Exception:
+                    pass
+
+        return found
+
+    def _is_contradiction(self, text_a: str, text_b: str) -> bool:
+        """Check if two texts contradict — LLM if available, heuristic fallback."""
+        # Heuristic first (fast, offline)
+        if self._heuristic_contradiction(text_a, text_b):
+            return True
+        # LLM confirmation
+        if self.llm_model and self.api_key:
+            return self._llm_contradiction_check(text_a, text_b)
+        return False
+
+    def _heuristic_contradiction(self, a: str, b: str) -> bool:
+        """Simple negation-pair heuristic."""
+        a_lower = a.lower()
+        b_lower = b.lower()
+        for pos, neg in self.NEGATION_PAIRS:
+            if pos in a_lower and neg in b_lower:
+                return True
+            if neg in a_lower and pos in b_lower:
+                return True
+        return False
+
+    def _llm_contradiction_check(self, text_a: str, text_b: str) -> bool:
+        """Ask LLM if two statements contradict each other."""
+        try:
+            prompt = CONTRADICTION_PROMPT.format(a=text_a, b=text_b)
+            if self._use_openclaw or not self.llm_model.startswith("claude"):
+                payload = json.dumps({
+                    "model": self.llm_model,
+                    "messages": [{"role": "user", "content": prompt}],
+                    "max_tokens": 5,
+                    "temperature": 0.0,
+                }).encode()
+                req = urllib.request.Request(
+                    f"{self.base_url}/chat/completions",
+                    data=payload,
+                    headers={
+                        "Authorization": f"Bearer {self.api_key}",
+                        "Content-Type": "application/json",
+                    },
+                )
+            else:
+                payload = json.dumps({
+                    "model": self.llm_model,
+                    "max_tokens": 5,
+                    "messages": [{"role": "user", "content": prompt}],
+                }).encode()
+                req = urllib.request.Request(
+                    "https://api.anthropic.com/v1/messages",
+                    data=payload,
+                    headers={
+                        "x-api-key": self.api_key,
+                        "anthropic-version": "2023-06-01",
+                        "Content-Type": "application/json",
+                    },
+                )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                raw = json.loads(resp.read())
+            if "choices" in raw:
+                answer = raw["choices"][0]["message"]["content"]
+            else:
+                answer = raw["content"][0]["text"]
+            return answer.strip().lower().startswith("yes")
+        except Exception:
+            return False
+
+    @classmethod
+    def from_ingester(cls, ingester) -> "ContradictionDetector":
+        """Create a ContradictionDetector from an existing LorienIngester."""
+        return cls(
+            store=ingester.store,
+            vector_index=ingester.vectors,
+            llm_model=ingester.llm_model,
+            api_key=ingester.api_key,
+            base_url=ingester.base_url,
+            use_openclaw=ingester._use_openclaw,
+        )