Quick Start

npm install @dakera-ai/dakera
# yarn add @dakera-ai/dakera | pnpm add @dakera-ai/dakera

go get github.com/dakera-ai/dakera-go

# Cargo.toml
[dependencies]
dakera-client = "0.12"
tokio = { version = "1", features = ["full"] }

brew install dakera-ai/tap/dk   # or see the CLI page for apt, dnf and install scripts
export DAKERA_API_KEY=my-dev-key
dk init # interactive setup: server URL and default namespace

# Memory 1: UI preference
curl -X POST http://localhost:3000/v1/memory/store \
  -H "Authorization: Bearer my-dev-key" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "my-agent",
    "content": "User prefers dark mode and minimal UI animations",
    "importance": 0.8,
    "tags": ["preference", "ui"]
  }'

# Memory 2: Team process
curl -X POST http://localhost:3000/v1/memory/store \
  -H "Authorization: Bearer my-dev-key" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "my-agent",
    "content": "Team standup is every morning at 9:30 AM in the #daily channel",
    "importance": 0.7,
    "tags": ["team", "process"]
  }'

# Memory 3: Infrastructure
curl -X POST http://localhost:3000/v1/memory/store \
  -H "Authorization: Bearer my-dev-key" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "my-agent",
    "content": "The deployment pipeline uses GitHub Actions with a staging environment on port 8080",
    "importance": 0.9,
    "tags": ["infra", "deployment"]
  }'

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

const client = new DakeraClient({
  baseUrl: process.env.DAKERA_API_URL ?? 'http://localhost:3000',
  apiKey: process.env.DAKERA_API_KEY,
});

// Memory 1: UI preference
await client.storeMemory('my-agent', {
  content: 'User prefers dark mode and minimal UI animations',
  importance: 0.8,
  tags: ['preference', 'ui'],
});

// Memory 2: Team process
await client.storeMemory('my-agent', {
  content: 'Team standup is every morning at 9:30 AM in the #daily channel',
  importance: 0.7,
  tags: ['team', 'process'],
});

// Memory 3: Infrastructure
await client.storeMemory('my-agent', {
  content: 'The deployment pipeline uses GitHub Actions with a staging environment on port 8080',
  importance: 0.9,
  tags: ['infra', 'deployment'],
});

import (
    "context"
    "fmt"
    "os"

    dakera "github.com/dakera-ai/dakera-go"
)

ctx := context.Background()
serverURL := os.Getenv("DAKERA_API_URL")
if serverURL == "" { serverURL = "http://localhost:3000" }

client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: serverURL,
    APIKey:  os.Getenv("DAKERA_API_KEY"),
})

// Memory 1: UI preference
imp1 := float32(0.8)
_, err := client.StoreMemory(ctx, "my-agent", dakera.StoreMemoryRequest{
    Content:    "User prefers dark mode and minimal UI animations",
    Importance: &imp1,
    Tags:       []string{"preference", "ui"},
})
if err != nil { panic(err) }

// Memory 2: Team process
imp2 := float32(0.7)
_, err = client.StoreMemory(ctx, "my-agent", dakera.StoreMemoryRequest{
    Content:    "Team standup is every morning at 9:30 AM in the #daily channel",
    Importance: &imp2,
    Tags:       []string{"team", "process"},
})

// Memory 3: Infrastructure
imp3 := float32(0.9)
_, err = client.StoreMemory(ctx, "my-agent", dakera.StoreMemoryRequest{
    Content:    "The deployment pipeline uses GitHub Actions with a staging environment on port 8080",
    Importance: &imp3,
    Tags:       []string{"infra", "deployment"},
})

use dakera_client::{DakeraClient, StoreMemoryRequest};

let client = DakeraClient::builder(
    std::env::var("DAKERA_API_URL").unwrap_or_else(|_| "http://localhost:3000".into()),
)
.api_key(std::env::var("DAKERA_API_KEY").unwrap_or_default())
.build()?;

// Memory 1: UI preference
client.store_memory(
    StoreMemoryRequest::new("my-agent", "User prefers dark mode and minimal UI animations")
        .with_importance(0.8)
        .with_tags(vec!["preference".into(), "ui".into()]),
).await?;

// Memory 2: Team process
client.store_memory(
    StoreMemoryRequest::new("my-agent", "Team standup is every morning at 9:30 AM in the #daily channel")
        .with_importance(0.7)
        .with_tags(vec!["team".into(), "process".into()]),
).await?;

// Memory 3: Infrastructure
client.store_memory(
    StoreMemoryRequest::new("my-agent", "The deployment pipeline uses GitHub Actions with a staging environment on port 8080")
        .with_importance(0.9)
        .with_tags(vec!["infra".into(), "deployment".into()]),
).await?;

curl -X POST http://localhost:3000/v1/memory/recall \
  -H "Authorization: Bearer my-dev-key" \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "my-agent", "query": "how does the team deploy code?"}'

const response = await client.recall('my-agent', 'how does the team deploy code?');

response.memories.forEach(m =>
  console.log(`${m.content} (score: ${m.score.toFixed(2)})`)
);

response, err := client.Recall(ctx, "my-agent", dakera.RecallRequest{
    Query: "how does the team deploy code?",
})

for _, m := range response.Memories {
    fmt.Printf("%s (score: %.2f)\n", m.Content, m.Score)
}

use dakera_client::RecallRequest;

let response = client
    .recall(RecallRequest::new("my-agent", "how does the team deploy code?"))
    .await?;

for m in &response.memories {
    println!("{} (score: {:.2})", m.content, m.score);
}

# Start a session
curl -X POST http://localhost:3000/v1/sessions/start \
  -H "Authorization: Bearer my-dev-key" \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "my-agent", "metadata": {"task": "onboarding"}}'
# → {"session": {"id": "sess_18a3b8e01a2c3d04", ...}}

# Store a memory within the session
curl -X POST http://localhost:3000/v1/memory/store \
  -H "Authorization: Bearer my-dev-key" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "my-agent",
    "session_id": "sess_18a3b8e01a2c3d04",
    "content": "User completed the quickstart guide and stored 3 test memories",
    "importance": 0.6
  }'

# End the session with a summary
curl -X POST http://localhost:3000/v1/sessions/sess_18a3b8e01a2c3d04/end \
  -H "Authorization: Bearer my-dev-key" \
  -H "Content-Type: application/json" \
  -d '{"summary": "Completed user onboarding — stored preferences, team info, and infra context"}'

// Start a session
const session = await client.startSession('my-agent', { task: 'onboarding' });

// Store a memory within the session
await client.storeMemory('my-agent', {
  session_id: session.id,
  content: 'User completed the quickstart guide and stored 3 test memories',
  importance: 0.6,
});

// End the session with a summary (dakera-js 0.12.2 and later)
await client.endSession(session.id, { summary: 'Completed the quickstart' });

// Start a session
session, err := client.StartSession(ctx, dakera.StartSessionRequest{
    AgentID:  "my-agent",
    Metadata: map[string]interface{}{"task": "onboarding"},
})

// Store a memory within the session
sessImp := float32(0.6)
client.StoreMemory(ctx, "my-agent", dakera.StoreMemoryRequest{
    SessionID:  session.ID,
    Content:    "User completed the quickstart guide and stored 3 test memories",
    Importance: &sessImp,
})

// End the session
client.EndSession(ctx, session.ID) // dakera-go v0.12.2 cannot send a summary

// Start a session (start_session_with_metadata attaches metadata)
let session = client.start_session("my-agent").await?;

// Store a memory within the session
client.store_memory(
    StoreMemoryRequest::new("my-agent", "User completed the quickstart guide and stored 3 test memories")
        .with_importance(0.6)
        .with_session(session.id.clone()),
).await?;

// End the session with a summary
client.end_session(
    &session.id,
    Some("Completed user onboarding — stored preferences, team info, and infra context".to_string()),
).await?;