Knowledge Graph Entity Linking

from dakera import DakeraClient

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

# Store memories — entity graph is built automatically
client.store_memory(
    agent_id="crm-agent",
    content="Sarah Kim is VP Sales at Acme Corp and owns the CloudMigrate Q2 deal worth $240k",
    importance=0.9,
    memory_type="semantic",
    tags=["crm", "contact", "deal"]
)

client.store_memory(
    agent_id="crm-agent",
    content="Marcus Lee is the technical champion at Acme Corp. He knows Sarah Kim and evaluates AWS for the CloudMigrate project.",
    importance=0.85,
    tags=["crm", "contact", "champion"]
)

client.store_memory(
    agent_id="crm-agent",
    content="Acme Corp is headquartered in San Francisco and has 850 employees in the fintech sector.",
    importance=0.75,
    tags=["crm", "account"]
)

# Retrieve the full knowledge graph
graph = client.knowledge_graph(agent_id="crm-agent")
# Returns: {"entities": [...], "relationships": [...]}

entities = graph["entities"]
# [
#   {"id": "ent_001", "label": "Sarah Kim", "type": "Person", "ref_count": 2},
#   {"id": "ent_002", "label": "Acme Corp", "type": "Organization", "ref_count": 3},
#   {"id": "ent_003", "label": "CloudMigrate Q2", "type": "Deal", "ref_count": 2},
#   ...
# ]

# Traverse from Acme Corp outward to depth 2
# Finds: Sarah Kim, Marcus Lee, CloudMigrate Q2, AWS, San Francisco
neighbors = client.graph_traverse(
    agent_id="crm-agent",
    entity="Acme Corp",
    depth=2
)

# Find the shortest relationship path between two entities
path = client.graph_path(
    agent_id="crm-agent",
    from_entity="Sarah Kim",
    to_entity="AWS"
)
# path = ["Sarah Kim", -OWNS_DEAL-> "CloudMigrate Q2", -USES_VENDOR-> "AWS"]

# Multi-hop question answering:
# "Who at Acme Corp knows about AWS?"
acme_neighbors = client.graph_traverse(
    agent_id="crm-agent", entity="Acme Corp", depth=1
)
# Filter for persons who also EVALUATING AWS
for entity in acme_neighbors["entities"]:
    if entity["type"] == "Person":
        person_graph = client.graph_traverse(
            agent_id="crm-agent", entity=entity["label"], depth=1
        )
        aws_links = [e for e in person_graph["entities"] if e["label"] == "AWS"]
        if aws_links:
            print(f"{entity['label']} is evaluating AWS")

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

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

// Store contact and deal memories — entity linking happens automatically
await client.storeMemory('crm-agent', {
  content: 'Sarah Kim is VP Sales at Acme Corp and owns the CloudMigrate Q2 deal worth $240k',
  importance: 0.9,
  memoryType: 'semantic',
  tags: ['crm', 'contact', 'deal']
});

await client.storeMemory('crm-agent', {
  content: 'Marcus Lee is the technical champion at Acme Corp. He knows Sarah Kim and evaluates AWS.',
  importance: 0.85,
  tags: ['crm', 'contact', 'champion']
});

await client.storeMemory('crm-agent', {
  content: 'Acme Corp is headquartered in San Francisco, fintech sector, 850 employees.',
  importance: 0.75,
  tags: ['crm', 'account']
});

// Retrieve the full knowledge graph
const graph = await client.knowledgeGraph({ agentId: 'crm-agent' });
// { entities: [...], relationships: [...] }

// Traverse: who is connected to Acme Corp within 2 hops?
const neighbors = await client.graphTraverse({
  agentId: 'crm-agent',
  entity: 'Acme Corp',
  depth: 2
});

// Find shortest path between two entities
const path = await client.graphPath({
  agentId: 'crm-agent',
  fromEntity: 'Sarah Kim',
  toEntity: 'AWS'
});

// Build context for LLM from graph + semantic recall combined
async function answerWithGraph(query: string) {
  // Step 1: Extract entities from the query
  const queryEntities = await client.extractEntities(query);

  // Step 2: For each entity, traverse the graph
  const graphContext: string[] = [];
  for (const entity of queryEntities) {
    const subgraph = await client.graphTraverse({
      agentId: 'crm-agent',
      entity: entity.label,
      depth: 2
    });
    graphContext.push(...subgraph.entities.map((e: any) => e.label));
  }

  // Step 3: Use semantic recall for supporting memories
  const memories = await client.recall('crm-agent', query, { top_k: 6, min_importance: 0.6 });

  return {
    graphEntities: graphContext,
    semanticMemories: memories.memories.map((m: any) => m.content)
  };
}

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

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

// Store memories — GLiNER extracts entities automatically
client.store_memory("crm-agent", StoreMemoryRequest {
    content: "Sarah Kim is VP Sales at Acme Corp and owns the CloudMigrate Q2 deal worth $240k".into(),
    importance: Some(0.9),
    memory_type: Some("semantic".into()),
    tags: Some(vec!["crm".into(), "contact".into(), "deal".into()]),
    ..Default::default()
}).await?;

client.store_memory("crm-agent", StoreMemoryRequest {
    content: "Marcus Lee is the technical champion at Acme Corp evaluating AWS for CloudMigrate.".into(),
    importance: Some(0.85),
    tags: Some(vec!["crm".into(), "champion".into()]),
    ..Default::default()
}).await?;

// Knowledge graph and traversal via REST (not yet in Rust SDK)
// GET /v1/agents/crm-agent/graph
// GET /v1/agents/crm-agent/graph/traverse?entity=Acme+Corp&depth=2

// Semantic recall works fully from Rust SDK
let memories = client.recall("crm-agent", RecallRequest {
    query: "Who at Acme Corp is evaluating cloud vendors?".into(),
    top_k: Some(5),
    min_importance: Some(0.6),
    ..Default::default()
}).await?;

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

package main

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

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

    // Store CRM memories — entities extracted and linked automatically
    client.StoreMemory(ctx, "crm-agent", dakera.StoreMemoryRequest{
        Content:    "Sarah Kim is VP Sales at Acme Corp and owns the CloudMigrate Q2 deal worth $240k",
        Importance: 0.9,
        MemoryType: "semantic",
        Tags:       []string{"crm", "contact", "deal"},
    })

    client.StoreMemory(ctx, "crm-agent", dakera.StoreMemoryRequest{
        Content:    "Marcus Lee is technical champion at Acme Corp, knows Sarah Kim, evaluates AWS.",
        Importance: 0.85,
        Tags:       []string{"crm", "champion"},
    })

    // Traverse graph from Acme Corp (depth 2)
    neighbors, err := client.GraphTraverse(ctx, dakera.GraphTraverseRequest{
        AgentID: "crm-agent",
        Entity:  "Acme Corp",
        Depth:   2,
    })
    if err != nil {
        panic(err)
    }

    for _, entity := range neighbors.Entities {
        fmt.Printf("Entity: %s (%s)
", entity.Label, entity.Type)
    }

    // Recall with semantic search
    results, _ := client.Recall(ctx, "crm-agent", dakera.RecallRequest{
        Query:         "Who evaluates cloud vendors at Acme Corp?",
        TopK:          5,
        MinImportance: 0.6,
    })

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