memanto

cd memanto
pip install -e .

python -m cli.main --help

memanto

╭──────────────────────────────────────────╮
│ MEMANTO CLI Initialization                 │
│ Setting up your MEMANTO configuration...   │
╰──────────────────────────────────────────╯

Enter your Moorcheh API key: ********

Testing connection to MEMANTO server...
✓ Connection successful!
Server version: 0.1.0

Configuration saved to: /home/user/.memanto/config.yaml

Next steps:
  1. Create and activate an agent: memanto agent create my-agent
  2. Start storing memories: memanto remember 'your memory here'

memanto agent create my-agent --pattern tool

memanto remember "Implemented authentication using JWT tokens" \
  --type decision \
  --tags "authentication,security" \
  --confidence 0.9

memanto recall "authentication" --limit 5

memanto answer "How did we implement authentication?"

memanto [OPTIONS]

memanto

memanto agent create AGENT_ID [OPTIONS]

# Create and activate a tool-using agent
python -m cli.main agent create code-assistant --pattern tool

# Create and activate a support agent with description
memanto agent create researcher \
  --pattern support \
  --description "Agent for customer support and ticket triage"

memanto agent list

┏━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┓
┃ Agent ID        ┃ Pattern ┃ Description             ┃ Status   ┃
┡━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━┩
│ code-assistant  │ tool    │ Code assistant          │ 🟢 Active│
│ researcher      │ support │ Support assistant       │          │
└─────────────────┴─────────┴────────────────────────┴──────────┘

memanto agent activate AGENT_ID [OPTIONS]

# Activate with default 6-hour session
python -m cli.main agent activate code-assistant

# Activate with 8-hour session
memanto agent activate code-assistant --duration-hours 8

memanto agent deactivate

memanto agent delete AGENT_ID [OPTIONS]

# Delete with interactive prompts
memanto agent delete my-agent

# Force delete, skip confirmation (still asks about cloud memories)
memanto agent delete my-agent --force

# Fully non-interactive, purging cloud memories too
memanto agent delete my-agent --force --delete-memories

memanto remember CONTENT [OPTIONS]

# Store a simple fact
python -m cli.main remember "User prefers dark mode"

# Store a decision with metadata
python -m cli.main remember "Switched to PostgreSQL for better JSON support" \
  --type decision \
  --title "Database Migration Decision" \
  --confidence 0.95 \
  --tags "database,architecture,postgresql"

# Store a commitment
python -m cli.main remember "Must complete security audit by end of month" \
  --type commitment \
  --tags "security,deadline"

✓ Memory stored successfully!
Memory ID: mem_abc123xyz
Type: decision | Confidence: 0.95

memanto upload FILE_PATH

# Upload a PDF document
memanto upload report.pdf

# Upload a markdown file
memanto upload SECURITY.md

OK File uploaded successfully!
File: SECURITY.md
Size: 0.01 MB
Namespace: agent:my-agent
Completed in 3.21s

memanto recall QUERY [OPTIONS]

# Basic search
python -m cli.main recall "authentication"

# Search with filters
python -m cli.main recall "security" \
  --type decision \
  --min-confidence 0.8 \
  --limit 5

# Search by tags
python -m cli.main recall "architecture" \
  --tags "database,backend" \
  --limit 20

Found 3 memories:

╭─ Memory 1 ──────────────────────────────────────────╮
│ Database Migration Decision                         │
│                                                      │
│ Switched to PostgreSQL for better JSON support      │
│ and advanced indexing capabilities...               │
│                                                      │
│ Type: decision | Confidence: 0.95 | Score: 0.927    │
│ Created: 2025-12-27T14:30:00Z                       │
╰─────────────────────────────────────────────────────╯

╭─ Memory 2 ──────────────────────────────────────────╮
│ ...                                                  │
╰─────────────────────────────────────────────────────╯

memanto answer QUESTION [OPTIONS]

# Ask about project decisions
memanto answer "Why did we choose PostgreSQL?"

# Ask with more context
memanto answer "What security measures have we implemented?" --limit 10

╭─ RAG Response ──────────────────────────────────────╮
│ Question: Why did we choose PostgreSQL?             │
│                                                      │
│ Answer:                                              │
│ We chose PostgreSQL because it provides better      │
│ JSON support and advanced indexing capabilities     │
│ compared to our previous database solution...       │
╰─────────────────────────────────────────────────────╯

Used 3 memories as context:
  1. Database Migration Decision (score: 0.927)
  2. Backend Architecture Review (score: 0.854)
  3. Performance Optimization Notes (score: 0.781)

memanto memory expire mem-123
memanto memory expire mem-123 --reason superseded-by-rewrite

memanto memory restore mem-123

memanto recall "deploy process"            # both, labelled
memanto recall "deploy process" --active   # active only
memanto recall "deploy process" --expired  # expired only

memanto policy list-preset        # list conservative / balanced / aggressive
memanto policy apply-preset balanced   # shows the preset in full, then asks

memanto policy show
memanto policy show --agent my-agent

memanto policy apply --dry-run    # what would expire, then stop
memanto policy apply              # same preview, then asks to confirm
memanto policy apply --yes        # skip the confirmation

memanto policy purge --dry-run
memanto policy purge

version: 1
retention:                 # broad strokes, per memory type
  context: 7d
  event: 30d
  preference: never
rules:                     # sharper; first match wins over the table
  - name: pinned
    match: {tags: [pinned]}
    expire_after: never    # pins a memory the table would expire
  - name: low-confidence-imports
    match:
      provenance: [imported]
      confidence_below: 0.5
    expire_after: 7d
purge_expired_after: never

memanto session info

┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Property       ┃ Value                          ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ Agent ID       │ code-assistant                 │
│ Session Token  │ eyJhbGciOiJIUzI1NiI...         │
└────────────────┴────────────────────────────────┘

memanto config show

┏━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Setting          ┃ Value                        ┃
┡━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ Config File      │ /home/user/.memanto/config.yaml│
│ Server URL       │ localhost:8000               │
│ API Key          │ ***configured***             │
│ Active Agent     │ code-assistant               │
│ Session Active   │ yes                          │
│ Interactive Mode │ True                         │
│ Smart Parse      │ True                         │
└──────────────────┴──────────────────────────────┘

# Morning: Activate your agent
memanto agent activate dev-assistant

# Throughout the day: Store important decisions and facts
memanto remember "Fixed authentication bug in login endpoint" \
  --type decision \
  --tags "bugfix,authentication"

memanto remember "User requested dark mode feature" \
  --type instruction \
  --tags "feature-request,ui"

# Review day's work
memanto recall "today" --limit 20

# End of day: Deactivate
memanto agent deactivate

# Store architecture decisions
memanto remember "Using microservices architecture with API gateway" \
  --type decision \
  --title "Architecture Pattern" \
  --tags "architecture,microservices" \
  --confidence 1.0

# Store team guidelines
memanto remember "All PRs require 2 approvals before merge" \
  --type instruction \
  --tags "process,code-review"

# Query the knowledge base
memanto answer "What are our code review requirements?"

# Create and auto-activate support agent
memanto agent create support-assistant --pattern support

# Store research findings
memanto remember "Paper XYZ shows 30% improvement in model accuracy" \
  --type fact \
  --tags "research,ml,paper-xyz" \
  --confidence 0.9

# Search research by topic
memanto recall "model accuracy improvements" --limit 10

# Synthesize findings
memanto answer "What papers discuss model accuracy improvements?"

version: "2.0"

server:
  url: "localhost"
  port: 8000
  auto_start: false

moorcheh:
  api_key_encrypted: "gAAAAABf..."  # Fernet encrypted

session:
  default_duration_hours: 6
  auto_extend: true

cli:
  interactive_mode: true
  smart_parse: true
  color_output: true
  compact_view: false

# Answer configuration (all optional — defaults shown)
answer:
  model: "anthropic.claude-sonnet-4-6"  # LLM used for answer
  temperature: 0.7        # LLM temperature (0.0–1.0)
  answer_limit: 5         # context memories passed to LLM for `answer`
  threshold: 0.15         # similarity floor applied only when kiosk_mode is true
  kiosk_mode: false       # set true to filter low-relevance results using threshold

# Recall configuration
recall:
  limit: 10               # top-N results returned by `recall`

active_agent_id: "code-assistant"
active_session_token: "eyJhbGciOiJIUzI1NiI..."

memanto

# List available agents
memanto agent list

# Activate one
memanto agent activate <agent-id>

# Get new API key from Moorcheh dashboard
# Reconfigure by running setup again
memanto

# Reactivate the agent
memanto agent activate <agent-id>

# 1. Setup
memanto

# 2. Create and auto-activate project-specific agent
memanto agent create project-alpha --pattern tool \
  --description "Agent for Project Alpha development"

# 3. (Optional) Reactivate or change duration
memanto agent activate project-alpha --duration-hours 8

# 4. Store initial context
memanto remember "Project uses Python 3.11, FastAPI, PostgreSQL" \
  --type fact \
  --title "Tech Stack" \
  --tags "project-setup,stack"

memanto remember "API versioning using /api/v2/ prefix" \
  --type decision \
  --tags "api,architecture"

# 5. Work session...
memanto remember "Implemented user authentication with JWT" \
  --type decision \
  --tags "auth,security"

# 6. Review progress
memanto recall "authentication security" --limit 5

# 7. Get context for next task
memanto answer "What have we implemented for security so far?"

# Development agent
memanto agent create dev --pattern tool
memanto agent activate dev
memanto remember "Implemented feature X" --type fact

# Switch to support agent (auto-activates)
memanto agent deactivate
memanto agent create support --pattern support
memanto remember "Found paper on optimization technique Y" --type fact

# Switch back
memanto agent deactivate
memanto agent activate dev

#!/bin/bash
# import-knowledge.sh

AGENT_ID="knowledge-base"

# Activate agent
memanto agent activate $AGENT_ID

# Import facts from file
while IFS='|' read -r title content tags; do
  memanto remember "$content" \
    --title "$title" \
    --type fact \
    --tags "$tags" \
    --confidence 1.0
done < knowledge.txt

echo "Import complete!"

#!/usr/bin/env python3
import subprocess
import json

def memanto_cli(*args):
    """Helper to call MEMANTO CLI"""
    cmd = ["memanto"] + list(args)
    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.stdout

# Store multiple memories
memories = [
    ("Decision A", "fact", "tag1,tag2"),
    ("Decision B", "decision", "tag2,tag3"),
]

for title, mem_type, tags in memories:
    memanto_cli("remember", title, "--type", mem_type, "--tags", tags)

# Search and process
results = memanto_cli("recall", "decision", "--limit", 10)
print(results)