Temporal Event Tracking

from dakera import DakeraClient
from datetime import datetime, date
from typing import Optional

client = DakeraClient(base_url="http://localhost:3300", api_key="dk-...")

class PortfolioEventTracker:
    """Financial event tracker using Dakera temporal memory."""

    IMPORTANCE_BY_TYPE = {
        "major_trade": 0.92,
        "rebalance": 0.88,
        "minor_trade": 0.78,
        "dividend": 0.65,
        "alert": 0.70,
        "price_target": 0.75,
    }

    def __init__(self, user_id: str):
        self.agent_id = f"portfolio-{user_id}"

    def track_event(
        self,
        event_description: str,
        event_type: str,
        event_date: Optional[date] = None,
        importance: Optional[float] = None,
        tags: Optional[list] = None
    ) -> dict:
        """
        Store a portfolio event with embedded date.

        Always embeds the ISO date in the content so BM25 can match it.
        """
        dt = event_date or date.today()
        date_str = dt.strftime("%Y-%m-%d")

        # Embed date in content for BM25 matching
        content = f"On {date_str}, {event_description}"

        base_tags = ["event", event_type.replace("_", "-")]
        if tags:
            base_tags.extend(tags)

        return client.store_memory(
            agent_id=self.agent_id,
            content=content,
            memory_type="episodic",
            importance=importance or self.IMPORTANCE_BY_TYPE.get(event_type, 0.75),
            tags=base_tags
        )

    def query_events(self, query: str, top_k: int = 20) -> list[dict]:
        """Natural language temporal query."""
        results = client.recall(
            agent_id=self.agent_id,
            query=query,
            top_k=top_k,
            min_importance=0.5
        )
        return results.get("memories", [])

    def get_recent_summary(self, period: str = "last 3 months") -> str:
        """Build a portfolio summary for a time period."""
        events = self.query_events(
            f"all portfolio trades, dividends, and significant events in the {period}",
            top_k=30
        )
        if not events:
            return f"No events found for {period}."

        lines = [f"Portfolio events ({period}):"]
        for e in events:
            lines.append(f"  - {e['content']}")
        return "
".join(lines)

# Track events as they happen
tracker = PortfolioEventTracker("alice")

tracker.track_event(
    "bought 0.5 BTC at $94,200. Total BTC position: 0.8 BTC.",
    event_type="major_trade",
    event_date=date(2026, 1, 15),
    tags=["crypto", "buy"]
)

tracker.track_event(
    "BTC hit $112,000. Sold 0.2 BTC at $112,000 (profit: $3,560). Remaining: 0.6 BTC.",
    event_type="major_trade",
    event_date=date(2026, 3, 21),
    tags=["crypto", "sell", "profit"]
)

tracker.track_event(
    "TSLA missed earnings by 18%. Sold all 15 TSLA shares at $148 (entry: $196, loss: -$720).",
    event_type="major_trade",
    event_date=date(2026, 4, 10),
    tags=["equity", "sell", "loss", "earnings"]
)

tracker.track_event(
    "received AAPL dividend: $23.40 (10 shares x $2.34/share).",
    event_type="dividend",
    event_date=date(2026, 2, 10),
    tags=["equity", "income"]
)

# Natural language temporal queries
print(tracker.get_recent_summary("last 3 months"))

# User asks: "How did my crypto do this year?"
crypto_events = tracker.query_events("cryptocurrency Bitcoin BTC trades performance this year")
for e in crypto_events:
    print(e["content"])

import { DakeraClient } from '@dakera-ai/dakera';

const client = new DakeraClient({ baseUrl: 'http://localhost:3300', apiKey: 'dk-...' });

interface PortfolioEvent {
  description: string;
  eventType: 'major_trade' | 'rebalance' | 'minor_trade' | 'dividend' | 'alert';
  eventDate?: Date;
  importance?: number;
  tags?: string[];
}

const IMPORTANCE_MAP: Record<string, number> = {
  major_trade: 0.92,
  rebalance: 0.88,
  minor_trade: 0.78,
  dividend: 0.65,
  alert: 0.70,
};

class PortfolioEventTracker {
  private agentId: string;

  constructor(userId: string) {
    this.agentId = `portfolio-${userId}`;
  }

  async trackEvent(event: PortfolioEvent): Promise<void> {
    const dt = event.eventDate ?? new Date();
    const dateStr = dt.toISOString().split('T')[0]; // YYYY-MM-DD
    const content = `On ${dateStr}, ${event.description}`;

    const baseTags = ['event', event.eventType.replace('_', '-')];
    const allTags = event.tags ? [...baseTags, ...event.tags] : baseTags;

    await client.storeMemory(this.agentId, {
      content,
      memoryType: 'episodic',
      importance: event.importance ?? IMPORTANCE_MAP[event.eventType] ?? 0.75,
      tags: allTags,
    });
  }

  async queryEvents(query: string, topK = 20): Promise<Array<{content: string}>> {
    const results = await client.recall(this.agentId, query, {
      top_k: topK,
      min_importance: 0.5,
    });
    return results.memories;
  }

  async getPortfolioSummary(period: string): Promise<string> {
    const events = await this.queryEvents(
      `all portfolio trades, dividends, significant events in the ${period}`,
      30
    );
    if (!events.length) return `No events found for ${period}.`;
    return events.map(e => `- ${e.content}`).join('
');
  }
}

// Usage
const tracker = new PortfolioEventTracker('alice');

await tracker.trackEvent({
  description: 'bought 0.5 BTC at $94,200. Total BTC: 0.8 BTC.',
  eventType: 'major_trade',
  eventDate: new Date('2026-01-15'),
  tags: ['crypto', 'buy'],
});

await tracker.trackEvent({
  description: 'BTC hit $112,000. Sold 0.2 BTC (profit: $3,560). Remaining: 0.6 BTC.',
  eventType: 'major_trade',
  eventDate: new Date('2026-03-21'),
  tags: ['crypto', 'sell', 'profit'],
});

await tracker.trackEvent({
  description: 'TSLA missed earnings by 18%. Sold 15 shares at $148 (loss: -$720).',
  eventType: 'major_trade',
  eventDate: new Date('2026-04-10'),
  tags: ['equity', 'sell', 'loss'],
});

// Temporal query
const summary = await tracker.getPortfolioSummary('last 3 months');
console.log(summary);

use dakera_rs::{Client, StoreMemoryRequest, RecallRequest};
use chrono::NaiveDate;

let client = Client::new("http://localhost:3300", "dk-...");

// Helper: format event with embedded ISO date
fn make_event_content(date: NaiveDate, description: &str) -> String {
    format!("On {}, {}", date.format("%Y-%m-%d"), description)
}

let agent_id = "portfolio-alice";

// Track BTC buy
client.store_memory(agent_id, StoreMemoryRequest {
    content: make_event_content(
        NaiveDate::from_ymd_opt(2026, 1, 15).unwrap(),
        "bought 0.5 BTC at $94,200. Total BTC position: 0.8 BTC."
    ),
    memory_type: "episodic".into(),
    importance: Some(0.88),
    tags: vec!["event".into(), "trade".into(), "crypto".into(), "buy".into()],
    ..Default::default()
}).await?;

// Track BTC sell at peak
client.store_memory(agent_id, StoreMemoryRequest {
    content: make_event_content(
        NaiveDate::from_ymd_opt(2026, 3, 21).unwrap(),
        "BTC hit $112,000. Sold 0.2 BTC (profit: $3,560). Remaining: 0.6 BTC."
    ),
    memory_type: "episodic".into(),
    importance: Some(0.92),
    tags: vec!["event".into(), "trade".into(), "crypto".into(), "sell".into(), "profit".into()],
    ..Default::default()
}).await?;

// Temporal query
let events = client.recall(agent_id, RecallRequest {
    query: "cryptocurrency trades and portfolio performance last 3 months".into(),
    top_k: Some(20),
    min_importance: Some(0.5),
    ..Default::default()
}).await?;

for event in &events.memories {
    println!("{}", event.content);
}

package main

import (
    "context"
    "fmt"
    "time"
    dakera "github.com/dakera-ai/dakera-go"
)

func trackPortfolioEvent(
    ctx context.Context,
    client *dakera.Client,
    agentID string,
    eventDate time.Time,
    description string,
    importance float64,
    tags []string,
) {
    dateStr := eventDate.Format("2006-01-02") // ISO 8601
    content := fmt.Sprintf("On %s, %s", dateStr, description)

    allTags := append([]string{"event"}, tags...)
    client.StoreMemory(ctx, agentID, dakera.StoreMemoryRequest{
        Content:    content,
        MemoryType: "episodic",
        Importance: importance,
        Tags:       allTags,
    })
}

func main() {
    client := dakera.NewClient("http://localhost:3300", "dk-...")
    ctx := context.Background()
    agentID := "portfolio-alice"

    trackPortfolioEvent(ctx, client, agentID,
        time.Date(2026, 1, 15, 0, 0, 0, 0, time.UTC),
        "bought 0.5 BTC at $94,200. Total BTC: 0.8 BTC.",
        0.88, []string{"trade", "crypto", "buy"})

    trackPortfolioEvent(ctx, client, agentID,
        time.Date(2026, 3, 21, 0, 0, 0, 0, time.UTC),
        "BTC hit $112,000. Sold 0.2 BTC (profit: $3,560). Remaining: 0.6 BTC.",
        0.92, []string{"trade", "crypto", "sell", "profit"})

    trackPortfolioEvent(ctx, client, agentID,
        time.Date(2026, 4, 10, 0, 0, 0, 0, time.UTC),
        "TSLA missed earnings by 18%. Sold 15 shares at $148 (loss: -$720).",
        0.90, []string{"trade", "equity", "sell", "loss"})

    // Temporal query
    events, _ := client.Recall(ctx, agentID, dakera.RecallRequest{
        Query: "cryptocurrency and equity trades last 3 months",
        TopK:  20,
    })

    for _, e := range events.Memories {
        fmt.Println(e.Content)
    }
}