memgentic 0.4.4__tar.gz

memgentic-0.4.4/.gitignore

@@ -0,0 +1,58 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+
+# UV
+# uv.lock is tracked for reproducible builds
+
+# Environment
+.env
+
+# Claude Code
+.claude/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Memgentic data (local development)
+*.db
+data/
+.memgentic/
+
+# Backup archives
+*.tar.gz
+
+# Docker
+docker-compose.override.yml
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Playwright
+.playwright-mcp/
+
+# Private/internal working docs (not for public repo)
+cloud/
+.mneme/
+
+# Rust
+target/
+Cargo.lock
+!memgentic-native/Cargo.lock

memgentic-0.4.4/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: memgentic
+Version: 0.4.4
+Summary: Universal AI memory layer — cross-tool knowledge capture with MCP, semantic search, and knowledge graphs
+Project-URL: Homepage, https://github.com/Chariton-kyp/memgentic
+Project-URL: Repository, https://github.com/Chariton-kyp/memgentic
+Project-URL: Issues, https://github.com/Chariton-kyp/memgentic/issues
+Author-email: Chariton Kypraios <chariton@ellinai.com>
+License-Expression: Apache-2.0
+Keywords: ai,claude,codex,gemini,knowledge-graph,mcp,memory,rag,semantic-search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite>=0.22
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.28
+Requires-Dist: mcp[cli]>=1.26
+Requires-Dist: pydantic-settings>=2.10
+Requires-Dist: pydantic>=2.12
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: qdrant-client>=1.17
+Requires-Dist: rich>=14.0
+Requires-Dist: structlog>=25.0
+Requires-Dist: tenacity>=9.0
+Requires-Dist: watchdog>=6.0
+Provides-Extra: dev
+Requires-Dist: google-genai>=1.50; extra == 'dev'
+Requires-Dist: langchain-anthropic>=1.0; extra == 'dev'
+Requires-Dist: langchain-core>=1.2; extra == 'dev'
+Requires-Dist: langchain-google-genai>=4.0; extra == 'dev'
+Requires-Dist: langchain-ollama>=0.3; extra == 'dev'
+Requires-Dist: langgraph>=1.1; extra == 'dev'
+Requires-Dist: networkx>=3.4; extra == 'dev'
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0; extra == 'dev'
+Requires-Dist: pytest>=9.0; extra == 'dev'
+Requires-Dist: ruff>=0.14; extra == 'dev'
+Provides-Extra: documents
+Requires-Dist: ebooklib>=0.18; extra == 'documents'
+Requires-Dist: openpyxl>=3.1; extra == 'documents'
+Requires-Dist: pdfminer-six>=20231228; extra == 'documents'
+Requires-Dist: python-docx>=1.1; extra == 'documents'
+Requires-Dist: python-pptx>=1.0; extra == 'documents'
+Requires-Dist: striprtf>=0.0.26; extra == 'documents'
+Provides-Extra: intelligence
+Requires-Dist: google-genai>=1.50; extra == 'intelligence'
+Requires-Dist: langchain-anthropic>=1.0; extra == 'intelligence'
+Requires-Dist: langchain-core>=1.2; extra == 'intelligence'
+Requires-Dist: langchain-google-genai>=4.0; extra == 'intelligence'
+Requires-Dist: langchain-ollama>=0.3; extra == 'intelligence'
+Requires-Dist: langgraph>=1.1; extra == 'intelligence'
+Requires-Dist: networkx>=3.4; extra == 'intelligence'
+Provides-Extra: observability
+Requires-Dist: opentelemetry-api>=1.28; extra == 'observability'
+Requires-Dist: opentelemetry-exporter-otlp>=1.28; extra == 'observability'
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.49; extra == 'observability'
+Requires-Dist: opentelemetry-instrumentation-sqlite3>=0.49; extra == 'observability'
+Requires-Dist: opentelemetry-sdk>=1.28; extra == 'observability'

memgentic-0.4.4/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: memgentic
+description: >-
+  Universal AI memory — recall past decisions, learnings, and context
+  from all your AI conversations (Claude Code, Gemini CLI, ChatGPT, Aider, etc.)
+context: fork
+---
+
+# Memgentic — Universal AI Memory Layer
+
+Memgentic captures knowledge from all your AI tools and makes it searchable.
+Every memory carries full provenance: which tool, which session, when it happened.
+
+## When to Use
+
+Search memory **before** doing work, not after:
+
+- **Starting a new task** — Check for prior decisions, context, or related work.
+- **Making architectural decisions** — Check if this was discussed before.
+- **Debugging** — Search for related past issues and solutions.
+- **User asks about history** — "what did we decide about...", "remember when...",
+  "how did we handle..."
+- **Encountering unfamiliar code** — Check for context on why it was written that way.
+- **Setting up or configuring something** — Check for user preferences and conventions.
+
+When in doubt, search. It costs little and prevents repeated work.
+
+## CLI Commands
+
+### Semantic Search (primary)
+
+```bash
+# Search memories by meaning
+memgentic search "database migration strategy"
+
+# Compact output — fewer tokens, good for scanning
+memgentic search "database migration strategy" --format compact
+
+# Filter by platform
+memgentic search "auth implementation" -s claude_code
+memgentic search "API design" -s chatgpt
+
+# Filter by content type
+memgentic search "why we chose PostgreSQL" -t decision
+memgentic search "user coding style" -t preference
+```
+
+### Store a Memory
+
+```bash
+# Save an important fact or decision
+memgentic remember "We chose Qdrant over Pinecone for local-first vector storage"
+
+# Memory type is auto-classified from content
+memgentic remember "Always use UV for package management"
+```
+
+### Other Commands
+
+```bash
+# See which platforms have memories and how many
+memgentic sources
+
+# Generate standalone context file with recent activity
+memgentic update-context
+
+# Explore knowledge graph around an entity
+memgentic graph "authentication"
+
+# Check system health
+memgentic doctor
+```
+
+## MCP Tools
+
+If the Memgentic MCP server is running, these tools are available directly:
+
+| Tool | Purpose |
+|------|---------|
+| `memgentic_recall` | Semantic search with source filtering |
+| `memgentic_remember` | Store a new memory |
+| `memgentic_search` | Full-text keyword search |
+| `memgentic_recent` | Recent memories by timestamp |
+| `memgentic_briefing` | Cross-agent briefing of recent activity |
+| `memgentic_sources` | List platforms and memory counts |
+| `memgentic_configure_session` | Set session-level source filters |
+| `memgentic_stats` | Memory statistics and analytics |
+| `memgentic_forget` | Archive (soft-delete) a memory |
+| `memgentic_export` | Export memories as JSON |
+
+### MCP Examples
+
+```
+memgentic_recall(query="authentication flow", limit=5)
+memgentic_recall(query="auth", sources=["claude_code", "chatgpt"])
+memgentic_remember(content="Project uses JWT with refresh tokens", memory_type="decision")
+memgentic_search(query="PostgreSQL", content_type="decision")
+memgentic_configure_session(exclude_sources=["codex_cli"])
+memgentic_briefing(hours=24)
+```
+
+## Efficient Retrieval Strategy
+
+Minimize token usage with a progressive approach:
+
+1. **Start compact** — Use `--format compact` for an overview of what exists.
+2. **Narrow down** — Add platform filter (`-s claude_code`) or type filter (`-t decision`)
+   when you know what you are looking for.
+3. **Full detail** — Drop `--format compact` only when you need the complete memory content.
+4. **Limit results** — Use `--limit` to cap the number of results returned.
+
+```bash
+# Step 1: Quick scan
+memgentic search "deployment" --format compact --limit 10
+
+# Step 2: Found relevant results, get details from a specific platform
+memgentic search "deployment" -s claude_code --limit 3
+```
+
+## Memory Types
+
+Memories are classified into types for filtering:
+
+| Type | Contains |
+|------|----------|
+| `decision` | Architectural and technical decisions with rationale |
+| `learning` | Things learned during development |
+| `preference` | User preferences, conventions, coding style |
+| `fact` | General knowledge and project context |
+| `bug_fix` | Bug fixes, root causes, and solutions |
+| `conversation_summary` | Summaries of complete sessions |
+
+Filter by type to get precise results:
+
+```bash
+memgentic search "database" -t decision    # Only decisions about databases
+memgentic search "testing" -t preference   # Only testing preferences
+memgentic search "auth" -t bug_fix         # Only auth-related bug fixes
+```
+
+## Cross-Platform Context
+
+Memgentic captures from multiple AI tools. Each memory records its source platform:
+
+| Platform | Source ID |
+|----------|-----------|
+| Claude Code | `claude_code` |
+| Gemini CLI | `gemini_cli` |
+| ChatGPT | `chatgpt` |
+| Aider | `aider` |
+| Codex CLI | `codex_cli` |
+| Copilot CLI | `copilot_cli` |
+| Claude Web/Desktop | `claude_web` |
+| Antigravity | `antigravity` |
+
+Use source filtering to scope searches:
+
+```bash
+# What did we discuss in Claude Code about this project?
+memgentic search "project architecture" -s claude_code
+
+# What did ChatGPT suggest about this topic?
+memgentic search "caching strategy" -s chatgpt
+
+# See all available sources
+memgentic sources
+```
+
+## Capture Methods
+
+Memories enter the system through:
+
+- **auto_daemon** — File watcher captures conversations automatically in the background.
+- **mcp_tool** — Stored via MCP tool calls during AI sessions.
+- **cli** — Manually saved via `memgentic remember`.
+- **json_import** — Bulk imported from conversation exports (ChatGPT, Claude Web).
+
+## Setup
+
+```bash
+# Check prerequisites
+memgentic doctor
+
+# Interactive setup (model selection, configuration)
+memgentic setup
+
+# Import existing conversations from all detected AI tools
+memgentic import-existing
+
+# Start background capture daemon
+memgentic daemon
+
+# Start MCP server for AI tool integration
+memgentic serve
+```

memgentic-0.4.4/hooks/__init__.py

@@ -0,0 +1,6 @@
+"""Memgentic hooks for Claude Code integration.
+
+Shell hooks that auto-inject memory context into Claude Code sessions:
+- UserPromptSubmit: searches for relevant memories on each prompt
+- SessionStart: injects recent cross-tool activity summary
+"""

memgentic-0.4.4/hooks/install.py

@@ -0,0 +1,79 @@
+"""Install Memgentic hooks into Claude Code settings.
+
+Adds a SessionStart hook that injects recent memory context at the
+beginning of each session. No UserPromptSubmit hook — memory retrieval
+is pull-based via MCP tools and SKILL.md subagent.
+
+Usage:
+    python -m memgentic.hooks.install [--global]
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+
+def get_hook_commands() -> dict[str, str]:
+    """Return hook event -> command mappings."""
+    hooks_dir = Path(__file__).parent.resolve()
+    python = sys.executable
+    return {
+        "SessionStart": f'"{python}" "{hooks_dir / "session_start.py"}"',
+    }
+
+
+def install_hooks(settings_path: Path) -> None:
+    """Add Memgentic hooks to a Claude Code settings file."""
+    if settings_path.exists():
+        data = json.loads(settings_path.read_text(encoding="utf-8"))
+    else:
+        settings_path.parent.mkdir(parents=True, exist_ok=True)
+        data = {}
+
+    hooks = data.setdefault("hooks", {})
+    commands = get_hook_commands()
+
+    for event, command in commands.items():
+        event_hooks = hooks.setdefault(event, [])
+
+        # Check if already installed
+        already = False
+        for matcher in event_hooks:
+            for h in matcher.get("hooks", []):
+                if "memgentic" in h.get("command", ""):
+                    already = True
+                    break
+
+        if already:
+            print(f"  {event}: already installed")
+            continue
+
+        event_hooks.append(
+            {
+                "hooks": [{"type": "command", "command": command}],
+            }
+        )
+        print(f"  {event}: installed")
+
+    settings_path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    print(f"\nSettings saved to: {settings_path}")
+
+
+def main() -> None:
+    use_global = "--global" in sys.argv
+
+    if use_global:
+        settings_path = Path.home() / ".claude" / "settings.json"
+        print("Installing Memgentic hooks globally...")
+    else:
+        settings_path = Path.cwd() / ".claude" / "settings.json"
+        print("Installing Memgentic hooks for this project...")
+
+    install_hooks(settings_path)
+    print("\nDone. Restart Claude Code to activate hooks.")
+
+
+if __name__ == "__main__":
+    main()

memgentic-0.4.4/hooks/session_start.py

@@ -0,0 +1,54 @@
+"""SessionStart hook — inject compact memory briefing into Claude's context.
+
+Runs once when a new Claude Code session starts. Queries SQLite directly
+for recent memories and outputs JSON with additionalContext for silent
+injection. No Ollama/embedding dependency — just a database read.
+
+Output format: Claude Code hookSpecificOutput.additionalContext (silent).
+Timeout: if anything fails, outputs nothing (safe degradation).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+
+
+def main() -> None:
+    try:
+        briefing = asyncio.run(asyncio.wait_for(_get_briefing(), timeout=3.0))
+        if briefing:
+            output = {
+                "hookSpecificOutput": {
+                    "additionalContext": (
+                        "## Memgentic Memory Context\n\n"
+                        + briefing
+                        + "\n\nUse memgentic_recall(query) for detailed memory search."
+                    )
+                }
+            }
+            json.dump(output, sys.stdout)
+    except Exception:
+        pass  # Silent failure — no output means no injection
+
+
+async def _get_briefing() -> str:
+    from memgentic.config import settings
+    from memgentic.processing.context_generator import generate_briefing
+    from memgentic.storage.metadata import MetadataStore
+
+    metadata_store = MetadataStore(settings.sqlite_path)
+    await metadata_store.initialize()
+    try:
+        return await generate_briefing(
+            metadata_store,
+            hours=settings.hook_briefing_hours,
+            limit=settings.hook_briefing_limit,
+        )
+    finally:
+        await metadata_store.close()
+
+
+if __name__ == "__main__":
+    main()

memgentic-0.4.4/hooks/user_prompt_submit.py

@@ -0,0 +1,22 @@
+"""UserPromptSubmit hook — lightweight memory availability nudge.
+
+Does NOT perform search (that would add 2-5s latency per prompt).
+Instead, outputs a minimal systemMessage reminding Claude that
+memory tools are available. Actual search happens via MCP tools
+or SKILL.md subagent when Claude decides it needs context.
+
+This matches the memsearch pattern: nudge, don't search.
+"""
+
+from __future__ import annotations
+
+
+def main() -> None:
+    # Intentionally empty — no per-prompt overhead.
+    # Memory retrieval is pull-based via MCP tools and SKILL.md.
+    # The SessionStart hook already provides initial context.
+    pass
+
+
+if __name__ == "__main__":
+    main()

memgentic-0.4.4/memgentic/__init__.py

@@ -0,0 +1,7 @@
+"""Memgentic — Universal AI Memory Layer.
+
+Zero-effort knowledge capture across all AI tools.
+Source-aware memory with semantic search, filtering, and knowledge graphs.
+"""
+
+__version__ = "0.1.0"

memgentic-0.4.4/memgentic/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.4.4"

memgentic-0.4.4/memgentic/adapters/__init__.py

@@ -0,0 +1,62 @@
+"""Memgentic adapters — parse conversations from different AI tools.
+
+Provides a registry of all available adapters for daemon watching
+and bulk import operations.
+"""
+
+from __future__ import annotations
+
+from memgentic.adapters.aider import AiderAdapter
+from memgentic.adapters.antigravity import AntigravityAdapter
+from memgentic.adapters.base import BaseAdapter
+from memgentic.adapters.chatgpt_import import ChatGPTImportAdapter
+from memgentic.adapters.claude_code import ClaudeCodeAdapter
+from memgentic.adapters.claude_web_import import ClaudeWebImportAdapter
+from memgentic.adapters.codex_cli import CodexCliAdapter
+from memgentic.adapters.copilot_cli import CopilotCliAdapter
+from memgentic.adapters.cursor import CursorAdapter
+from memgentic.adapters.gemini_cli import GeminiCliAdapter
+
+__all__ = [
+    "AiderAdapter",
+    "AntigravityAdapter",
+    "BaseAdapter",
+    "ChatGPTImportAdapter",
+    "ClaudeCodeAdapter",
+    "ClaudeWebImportAdapter",
+    "CodexCliAdapter",
+    "CopilotCliAdapter",
+    "CursorAdapter",
+    "GeminiCliAdapter",
+    "get_daemon_adapters",
+    "get_import_adapters",
+]
+
+
+def get_daemon_adapters() -> list[BaseAdapter]:
+    """Get adapters that support file-watching (have watch_paths).
+
+    These are used by the daemon to monitor directories for new conversations.
+    Aider is excluded — it has no fixed watch_paths (project-specific).
+    """
+    return [
+        ClaudeCodeAdapter(),
+        GeminiCliAdapter(),
+        CodexCliAdapter(),
+        CopilotCliAdapter(),
+        AntigravityAdapter(),
+    ]
+
+
+def get_import_adapters() -> list[BaseAdapter]:
+    """Get all adapters including import-only ones.
+
+    Import-only adapters (no watch_paths) are used by the import-existing
+    command and the REST API import endpoints.
+    """
+    return get_daemon_adapters() + [
+        AiderAdapter(),
+        ChatGPTImportAdapter(),
+        ClaudeWebImportAdapter(),
+        CursorAdapter(),
+    ]