Temporal Event Tracking

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

client = DakeraClient(base_url="http://localhost:3000", 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):
        """Store an event with its ISO date at the start of the content,
        where Dakera reads the event date and keyword search can match it."""
        dt = event_date or date.today()
        content = f"On {dt.isoformat()}, {event_description}"
        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=["event", event_type.replace("_", "-")] + (tags or []),
        )

    def query_events(self, query: str, top_k: int = 20):
        """Natural language temporal query."""
        return client.recall(agent_id=self.agent_id, query=query, top_k=top_k,
                             min_importance=0.5).memories

    def get_recent_summary(self, period: str = "last 3 months") -> str:
        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}."
        return "\n".join([f"Portfolio events ({period}):"] + [f"  - {e.content}" for e in events])


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("received AAPL dividend: $23.40 (10 shares x $2.34/share).",
                    event_type="dividend", event_date=date(2026, 2, 10), tags=["equity", "income"])
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"])

print(tracker.get_recent_summary("last 3 months"))

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

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

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

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(description: string, eventType: string, eventDate = new Date(), tags: string[] = []) {
    const dateStr = eventDate.toISOString().split('T')[0]; // YYYY-MM-DD
    await client.storeMemory(this.agentId, {
      content: `On ${dateStr}, ${description}`,
      memory_type: 'episodic',
      importance: IMPORTANCE_MAP[eventType] ?? 0.75,
      tags: ['event', eventType.replace('_', '-'), ...tags],
    });
  }

  async queryEvents(query: string, topK = 20) {
    const { memories } = await client.recall(this.agentId, query, { top_k: topK, min_importance: 0.5 });
    return 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('\n');
  }
}

const tracker = new PortfolioEventTracker('alice');
await tracker.trackEvent('bought 0.5 BTC at $94,200. Total BTC: 0.8 BTC.', 'major_trade', new Date('2026-01-15'), ['crypto', 'buy']);
await tracker.trackEvent('BTC hit $112,000. Sold 0.2 BTC (profit: $3,560). Remaining: 0.6 BTC.', 'major_trade', new Date('2026-03-21'), ['crypto', 'sell', 'profit']);
await tracker.trackEvent('TSLA missed earnings by 18%. Sold 15 shares at $148 (loss: -$720).', 'major_trade', new Date('2026-04-10'), ['equity', 'sell', 'loss']);

console.log(await tracker.getPortfolioSummary('last 3 months'));

use chrono::NaiveDate;
use dakera_client::{DakeraClient, RecallRequest, StoreMemoryRequest};

let client = DakeraClient::builder("http://localhost:3000").api_key("dk-...").build()?;
let agent = "portfolio-alice";

// The ISO date goes at the start of the content
fn event_content(date: NaiveDate, description: &str) -> String {
    format!("On {}, {}", date.format("%Y-%m-%d"), description)
}

for (date, description, tags) in [
    (NaiveDate::from_ymd_opt(2026, 1, 15).unwrap(),
     "bought 0.5 BTC at $94,200. Total BTC position: 0.8 BTC.", vec!["trade", "crypto", "buy"]),
    (NaiveDate::from_ymd_opt(2026, 3, 21).unwrap(),
     "BTC hit $112,000. Sold 0.2 BTC (profit: $3,560). Remaining: 0.6 BTC.", vec!["trade", "crypto", "sell"]),
] {
    client.store_memory(
        StoreMemoryRequest::new(agent, event_content(date, description))
            .with_importance(0.92)
            .with_tags(tags.into_iter().map(String::from).collect()),
    ).await?;
}

// Temporal query
let events = client.recall(
    RecallRequest::new(agent, "cryptocurrency trades and portfolio performance last 3 months").with_top_k(20),
).await?;
for event in &events.memories {
    println!("{}", event.content);
}

func trackPortfolioEvent(ctx context.Context, client *dakera.Client, agentID string,
    eventDate time.Time, description string, importance float32, tags []string) error {
    // The ISO date goes at the start of the content
    content := fmt.Sprintf("On %s, %s", eventDate.Format("2006-01-02"), description)
    _, err := client.StoreMemory(ctx, agentID, dakera.StoreMemoryRequest{
        Content:    content,
        Importance: &importance,
        Tags:       append([]string{"event"}, tags...),
    })
    return err
}

func main() {
    ctx := context.Background()
    client := dakera.NewClientWithOptions(dakera.ClientOptions{
        BaseURL: "http://localhost:3000",
        APIKey:  os.Getenv("DAKERA_API_KEY"),
    })
    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.92, []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.92, []string{"trade", "equity", "sell", "loss"})

    // Temporal query
    events, err := client.Recall(ctx, agentID, dakera.RecallRequest{
        Query: "cryptocurrency and equity trades last 3 months",
        TopK:  20,
    })
    if err != nil {
        log.Fatal(err)
    }
    for _, e := range events.Memories {
        fmt.Println(e.Content)
    }
}