Artemis Agentic Memory Layer

This document describes the integration between Artemis City core and the Artemis Agentic Memory Layer (MCP Server), enabling agents to interact with Obsidian vault as a persistent knowledge base.

This document describes the integration between Artemis City core and the Artemis Agentic Memory Layer (MCP Server), enabling agents to interact with Obsidian vault as a persistent knowledge base.

Overview

The memory integration bridge connects the Python-based Artemis City agent system with the Node.js MCP server, allowing:

• Persistent Context Storage: Agents can store and retrieve context across sessions
• Trust-Based Access Control: Memory operations filtered by agent trust scores
• Structured Knowledge Base: Obsidian vault acts as versioned source of truth
• Agent-Vault Interaction: Search, tag, and organize knowledge programmatically

---

Components

1. Memory Client (memory/integration/memory_client.py)

Python REST client for the MCP server with full coverage of 8 MCP operations.

Features:

• Bearer token authentication
• Standardized response format (MCPResponse)
• Automatic error handling
• Built-in HTTP client (no external dependencies)

Operations:

• get_context(path) - Read note content
• append_context(path, content) - Append to note
• update_note(path, content) - Replace note content
• search_notes(query) - Search vault
• list_notes(folder) - List notes in folder
• delete_note(path) - Delete note
• manage_frontmatter(path, action, key, value) - YAML frontmatter ops
• manage_tags(path, action, tags) - Tag management
• search_replace(path, search, replace) - Find and replace

Example:

from memory.integration import MemoryClient

client = MemoryClient(
    base_url="http://localhost:3000",
    api_key="your_mcp_api_key"
)

# Read a note
response = client.get_context("Daily/2025-11-23.md")
if response.success:
    print(response.data['content'])

# Store agent context
client.store_agent_context(
    "artemis",
    "Completed ATP integration successfully"
)

2. Trust Interface (memory/integration/trust_interface.py)

Trust-based access control for memory operations with decay model.

Features:

• Trust scores for agents (0.0-1.0)
• Trust levels (FULL, HIGH, MEDIUM, LOW, UNTRUSTED)
• Operation permission matrix
• Natural trust decay over time
• Reinforcement/penalty system

Trust Levels & Permissions:

Level	Score Range	Allowed Operations
FULL	0.9-1.0	read, write, delete, search, tag, update
HIGH	0.7-0.89	read, write, search, tag, update
MEDIUM	0.5-0.69	read, write, search, tag
LOW	0.3-0.49	read, search
UNTRUSTED	0.0-0.29	none

Example:

from memory.integration import get_trust_interface

trust = get_trust_interface()

# Check permission
if trust.can_perform_operation('artemis', 'write'):
    # Perform write operation
    trust.record_success('artemis')  # Reinforce trust
else:
    print("Access denied - insufficient trust")

# Get trust report
report = trust.get_trust_report()
print(f"Total entities: {report['total_entities']}")

3. Context Loader (memory/integration/context_loader.py)

High-level interface for loading and organizing context from vault.

Features:

• Load notes as ContextEntry objects
• Search vault with relevance scoring
• Load by tags or folders
• Agent history tracking
• Related content discovery
• Date range filtering

With Artemis Persona

Artemis can store and load context for continuity:

from agents.artemis import ArtemisPersona, ReflectionEngine
from memory.integration import MemoryClient, ContextLoader

persona = ArtemisPersona()
client = MemoryClient()
loader = ContextLoader()

# Load historical context
history = loader.load_agent_history("artemis", limit=20)

# Feed to reflection engine
engine = ReflectionEngine()
for entry in history:
    engine.add_conversation(entry.content)

# Generate synthesis
synthesis = engine.synthesize()

# Store synthesis back to vault
client.store_agent_context("artemis", synthesis, "Reflections")

With Instruction Hierarchy

Memory can provide agent-specific instructions:

from core.instructions import InstructionLoader
from memory.integration import ContextLoader

loader = ContextLoader()

# Load agent instructions from vault
agent_instructions = loader.load_note("Agents/artemis/instructions.md")

if agent_instructions:
    # Instructions loaded from Obsidian override local
    print("Using vault-stored instructions:")
    print(agent_instructions.content)

Planned improvements aligned with the plan:

1. Enhanced CLI Integration
   • Automatic context loading on startup
   • Persistent conversation history
   • Cross-session memory
2. MCP Configuration Helper
   • Auto-discovery of MCP server
   • Configuration validation
   • Health monitoring
3. Agent Communication
   • Message protocol with context hashing
   • Shared workspace in vault
   • Cross-agent knowledge graphs
4. Advanced Search
   • Semantic search with embeddings
   • Relevance ranking algorithms
   • Context-aware suggestions