Memory System

{
  "force": true
}

{
  "memory_id": "mem_123456789",
  "summary": "User performed weather analysis and calculations",
  "key_points": [
    "Analyzed weather in 5 cities",
    "Calculated temperature averages"
  ],
  "created_at": "2024-12-19T10:00:00Z"
}

from aphelion import Aphelion

client = Aphelion(api_key="your-api-key")

class IntelligentAssistant:
    def __init__(self, client):
        self.client = client
        self.context = None

    def load_context(self):
        """Load historical context for personalization."""
        self.context = self.client.memory.get_context()
        return self.context

    def search_memories(self, query, limit=5):
        """Search for relevant past interactions."""
        return self.client.memory.search(
            query=query,
            limit=limit,
            threshold=0.7
        )

    def process_with_context(self, user_input):
        """Process input with memory awareness."""
        # Search for relevant memories
        memories = self.search_memories(user_input)

        # Build context-aware response
        relevant_context = [
            m.summary for m in memories.results
            if m.similarity_score > 0.8
        ]

        if relevant_context:
            print(f"Found {len(relevant_context)} relevant memories")
            # Use context to enhance response

        return self.process(user_input)

# Usage
assistant = IntelligentAssistant(client)
assistant.load_context()

# Process with memory awareness
response = assistant.process_with_context(
    "What was the weather like last week?"
)

import { Aphelion } from 'aphelion';

const client = new Aphelion({ apiKey: process.env.APHELION_API_KEY });

async function createMemoryAwareSession() {
  // Load user context
  const context = await client.memory.getContext();

  // Create session with context
  const session = await client.sessions.create({
    services: context.user_preferences.preferred_tools
  });

  // Search relevant memories
  const memories = await client.memory.search({
    query: "recent activities",
    limit: 5
  });

  console.log(`Found ${memories.results.length} relevant memories`);
  console.log(`User preferences: ${JSON.stringify(context.user_preferences)}`);

  return session;
}

// Get memory statistics
async function getMemoryInsights() {
  const stats = await client.memory.getStats();

  console.log(`Total memories: ${stats.statistics.total_memories}`);
  console.log(`Sessions tracked: ${stats.statistics.total_sessions}`);
  console.log(`Storage used: ${stats.statistics.storage_used_mb} MB`);
}