Knowledge Graph Guide

package main

import (
    "context"
    "database/sql"
    "log"
    "github.com/google/uuid"
    _ "geodedb.com/geode"
)

type Entity struct {
    ID          string
    Name        string
    Description string
    Aliases     []string
    Source      string
    Confidence  float64
}

type Person struct {
    Entity
    BirthDate   string
    Nationality string
    Occupation  []string
}

func CreatePerson(ctx context.Context, db *sql.DB, person Person) (string, error) {
    person.ID = uuid.New().String()

    _, err := db.ExecContext(ctx, `
        CREATE (p:Person:Entity {
            id: ?,
            name: ?,
            description: ?,
            aliases: ?,
            birth_date: date(?),
            nationality: ?,
            occupation: ?,
            source: ?,
            confidence: ?,
            created_at: timestamp()
        })
    `, person.ID, person.Name, person.Description, person.Aliases,
       person.BirthDate, person.Nationality, person.Occupation,
       person.Source, person.Confidence)

    return person.ID, err
}

func main() {
    db, err := sql.Open("geode", "localhost:3141")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx := context.Background()

    id, err := CreatePerson(ctx, db, Person{
        Entity: Entity{
            Name:        "Marie Curie",
            Description: "Polish-French physicist and chemist",
            Aliases:     []string{"Maria Sklodowska", "Madame Curie"},
            Source:      "wikipedia",
            Confidence:  0.99,
        },
        BirthDate:   "1867-11-07",
        Nationality: "Polish-French",
        Occupation:  []string{"physicist", "chemist"},
    })
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Created person: %s", id)
}

import asyncio
from dataclasses import dataclass, field
from typing import List, Optional
from datetime import date
from uuid import uuid4
from geode_client import Client

@dataclass
class Entity:
    id: str = ""
    name: str = ""
    description: str = ""
    aliases: List[str] = field(default_factory=list)
    source: str = ""
    confidence: float = 1.0

@dataclass
class Person(Entity):
    birth_date: Optional[date] = None
    death_date: Optional[date] = None
    nationality: str = ""
    occupation: List[str] = field(default_factory=list)

async def create_person(client, person: Person) -> str:
    """Create a person entity in the knowledge graph."""
    person.id = str(uuid4())

    async with client.connection() as conn:
        await conn.execute("""
            CREATE (p:Person:Entity {
                id: $id,
                name: $name,
                description: $description,
                aliases: $aliases,
                birth_date: date($birth_date),
                nationality: $nationality,
                occupation: $occupation,
                source: $source,
                confidence: $confidence,
                created_at: timestamp()
            })
        """, {
            "id": person.id,
            "name": person.name,
            "description": person.description,
            "aliases": person.aliases,
            "birth_date": person.birth_date.isoformat() if person.birth_date else None,
            "nationality": person.nationality,
            "occupation": person.occupation,
            "source": person.source,
            "confidence": person.confidence
        })

    return person.id

async def main():
    client = Client(host="localhost", port=3141, skip_verify=True)

    person_id = await create_person(client, Person(
        name="Marie Curie",
        description="Polish-French physicist and chemist",
        aliases=["Maria Sklodowska", "Madame Curie"],
        birth_date=date(1867, 11, 7),
        nationality="Polish-French",
        occupation=["physicist", "chemist"],
        source="wikipedia",
        confidence=0.99
    ))

    print(f"Created person: {person_id}")

asyncio.run(main())

use geode_client::{Client, Value};
use std::collections::HashMap;
use uuid::Uuid;

#[derive(Debug)]
struct Person {
    id: String,
    name: String,
    description: String,
    aliases: Vec<String>,
    birth_date: String,
    nationality: String,
    occupation: Vec<String>,
    source: String,
    confidence: f64,
}

async fn create_person(
    conn: &mut geode_client::Connection,
    person: &mut Person,
) -> Result<String, Box<dyn std::error::Error>> {
    person.id = Uuid::new_v4().to_string();

    let mut params = HashMap::new();
    params.insert("id".to_string(), Value::string(&person.id));
    params.insert("name".to_string(), Value::string(&person.name));
    params.insert("description".to_string(), Value::string(&person.description));
    params.insert("aliases".to_string(), Value::list(
        person.aliases.iter().map(|a| Value::string(a)).collect()
    ));
    params.insert("birth_date".to_string(), Value::string(&person.birth_date));
    params.insert("nationality".to_string(), Value::string(&person.nationality));
    params.insert("occupation".to_string(), Value::list(
        person.occupation.iter().map(|o| Value::string(o)).collect()
    ));
    params.insert("source".to_string(), Value::string(&person.source));
    params.insert("confidence".to_string(), Value::float(person.confidence));

    conn.query_with_params(r#"
        CREATE (p:Person:Entity {
            id: $id,
            name: $name,
            description: $description,
            aliases: $aliases,
            birth_date: date($birth_date),
            nationality: $nationality,
            occupation: $occupation,
            source: $source,
            confidence: $confidence,
            created_at: timestamp()
        })
    "#, &params).await?;

    Ok(person.id.clone())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("127.0.0.1", 3141).skip_verify(true);
    let mut conn = client.connect().await?;

    let mut person = Person {
        id: String::new(),
        name: "Marie Curie".to_string(),
        description: "Polish-French physicist and chemist".to_string(),
        aliases: vec!["Maria Sklodowska".to_string(), "Madame Curie".to_string()],
        birth_date: "1867-11-07".to_string(),
        nationality: "Polish-French".to_string(),
        occupation: vec!["physicist".to_string(), "chemist".to_string()],
        source: "wikipedia".to_string(),
        confidence: 0.99,
    };

    let id = create_person(&mut conn, &mut person).await?;
    println!("Created person: {}", id);

    Ok(())
}

import { createClient, Client } from '@geodedb/client';
import { v4 as uuidv4 } from 'uuid';

interface Entity {
  id: string;
  name: string;
  description: string;
  aliases: string[];
  source: string;
  confidence: number;
}

interface Person extends Entity {
  birthDate?: string;
  deathDate?: string;
  nationality: string;
  occupation: string[];
}

async function createPerson(client: Client, person: Partial<Person>): Promise<string> {
  const id = uuidv4();

  await client.exec(`
    CREATE (p:Person:Entity {
      id: $id,
      name: $name,
      description: $description,
      aliases: $aliases,
      birth_date: date($birth_date),
      nationality: $nationality,
      occupation: $occupation,
      source: $source,
      confidence: $confidence,
      created_at: timestamp()
    })
  `, {
    params: {
      id,
      name: person.name,
      description: person.description,
      aliases: person.aliases || [],
      birth_date: person.birthDate,
      nationality: person.nationality,
      occupation: person.occupation || [],
      source: person.source,
      confidence: person.confidence || 1.0
    }
  });

  return id;
}

async function main() {
  const client = await createClient('quic://localhost:3141');

  const personId = await createPerson(client, {
    name: 'Marie Curie',
    description: 'Polish-French physicist and chemist',
    aliases: ['Maria Sklodowska', 'Madame Curie'],
    birthDate: '1867-11-07',
    nationality: 'Polish-French',
    occupation: ['physicist', 'chemist'],
    source: 'wikipedia',
    confidence: 0.99
  });

  console.log(`Created person: ${personId}`);
  await client.close();
}

main();

const std = @import("std");
const geode = @import("geode_client");
const uuid = @import("uuid");

const Person = struct {
    id: []const u8,
    name: []const u8,
    description: []const u8,
    aliases: []const []const u8,
    birth_date: []const u8,
    nationality: []const u8,
    occupation: []const []const u8,
    source: []const u8,
    confidence: f64,
};

pub fn createPerson(
    client: *geode.GeodeClient,
    allocator: std.mem.Allocator,
    person: *Person,
) ![]const u8 {
    const id = uuid.v4();
    person.id = &id;

    var params = std.json.ObjectMap.init(allocator);
    defer params.deinit();

    try params.put("id", .{ .string = &id });
    try params.put("name", .{ .string = person.name });
    try params.put("description", .{ .string = person.description });
    // ... add other parameters

    try client.sendRunGql(1,
        \\CREATE (p:Person:Entity {
        \\    id: $id,
        \\    name: $name,
        \\    description: $description,
        \\    aliases: $aliases,
        \\    birth_date: date($birth_date),
        \\    nationality: $nationality,
        \\    occupation: $occupation,
        \\    source: $source,
        \\    confidence: $confidence,
        \\    created_at: timestamp()
        \\})
    , .{ .object = params });

    _ = try client.receiveMessage(30000);

    return &id;
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = geode.GeodeClient.init(allocator, "localhost", 3141, true);
    defer client.deinit();

    try client.connect();
    try client.sendHello("knowledge-graph", "1.0.0");
    _ = try client.receiveMessage(30000);

    var person = Person{
        .id = "",
        .name = "Marie Curie",
        .description = "Polish-French physicist and chemist",
        .aliases = &[_][]const u8{ "Maria Sklodowska", "Madame Curie" },
        .birth_date = "1867-11-07",
        .nationality = "Polish-French",
        .occupation = &[_][]const u8{ "physicist", "chemist" },
        .source = "wikipedia",
        .confidence = 0.99,
    };

    const id = try createPerson(&client, allocator, &person);
    std.debug.print("Created person: {s}\n", .{id});
}

from dataclasses import dataclass
from typing import Any, Optional
import re

@dataclass
class Answer:
    value: Any
    confidence: float
    source: str
    explanation: Optional[str] = None

async def answer_question(client, question: str) -> Optional[Answer]:
    """Answer a natural language question using the knowledge graph."""

    # Pattern: "Where was X born?"
    born_match = re.match(r"[Ww]here was (.+?) born\??", question)
    if born_match:
        entity_name = born_match.group(1)
        async with client.connection() as conn:
            result, _ = await conn.query("""
                MATCH (p:Person {name: $name})-[:BORN_IN]->(location:Location)
                RETURN location.name AS answer, p.confidence AS confidence, p.source AS source
            """, {"name": entity_name})

            if result.rows:
                row = result.rows[0]
                return Answer(
                    value=row['answer'].as_string,
                    confidence=row['confidence'].as_float,
                    source=row['source'].as_string,
                    explanation=f"{entity_name} was born in {row['answer'].as_string}"
                )

    # Pattern: "Who founded X?"
    founded_match = re.match(r"[Ww]ho founded (.+?)\??", question)
    if founded_match:
        org_name = founded_match.group(1)
        async with client.connection() as conn:
            result, _ = await conn.query("""
                MATCH (p:Person)-[:FOUNDED]->(org:Organization {name: $name})
                RETURN p.name AS answer, p.confidence AS confidence, p.source AS source
            """, {"name": org_name})

            if result.rows:
                row = result.rows[0]
                return Answer(
                    value=row['answer'].as_string,
                    confidence=row['confidence'].as_float,
                    source=row['source'].as_string,
                    explanation=f"{row['answer'].as_string} founded {org_name}"
                )

    # Pattern: "What is the capital of X?"
    capital_match = re.match(r"[Ww]hat is the capital of (.+?)\??", question)
    if capital_match:
        country_name = capital_match.group(1)
        async with client.connection() as conn:
            result, _ = await conn.query("""
                MATCH (capital:Location)-[:CAPITAL_OF]->(country:Location {name: $name})
                RETURN capital.name AS answer
            """, {"name": country_name})

            if result.rows:
                return Answer(
                    value=result.rows[0]['answer'].as_string,
                    confidence=1.0,
                    source="knowledge_graph",
                    explanation=f"The capital of {country_name} is {result.rows[0]['answer'].as_string}"
                )

    return None

async def main():
    client = Client(host="localhost", port=3141, skip_verify=True)

    questions = [
        "Where was Marie Curie born?",
        "Who founded Microsoft?",
        "What is the capital of France?"
    ]

    for q in questions:
        answer = await answer_question(client, q)
        if answer:
            print(f"Q: {q}")
            print(f"A: {answer.value} (confidence: {answer.confidence})")
            print()

use regex::Regex;

#[derive(Debug)]
struct Answer {
    value: String,
    confidence: f64,
    source: String,
    explanation: Option<String>,
}

async fn answer_question(
    conn: &mut geode_client::Connection,
    question: &str,
) -> Result<Option<Answer>, Box<dyn std::error::Error>> {
    // Pattern: "Where was X born?"
    let born_re = Regex::new(r"[Ww]here was (.+?) born\??")?;
    if let Some(caps) = born_re.captures(question) {
        let entity_name = &caps[1];
        let mut params = HashMap::new();
        params.insert("name".to_string(), Value::string(entity_name));

        let (page, _) = conn.query_with_params(r#"
            MATCH (p:Person {name: $name})-[:BORN_IN]->(location:Location)
            RETURN location.name AS answer, p.confidence AS confidence, p.source AS source
        "#, &params).await?;

        if let Some(row) = page.rows.first() {
            return Ok(Some(Answer {
                value: row.get("answer").unwrap().as_string()?,
                confidence: row.get("confidence").unwrap().as_float()?,
                source: row.get("source").unwrap().as_string()?,
                explanation: Some(format!("{} was born in {}",
                    entity_name, row.get("answer").unwrap().as_string()?)),
            }));
        }
    }

    // Pattern: "Who founded X?"
    let founded_re = Regex::new(r"[Ww]ho founded (.+?)\??")?;
    if let Some(caps) = founded_re.captures(question) {
        let org_name = &caps[1];
        let mut params = HashMap::new();
        params.insert("name".to_string(), Value::string(org_name));

        let (page, _) = conn.query_with_params(r#"
            MATCH (p:Person)-[:FOUNDED]->(org:Organization {name: $name})
            RETURN p.name AS answer, p.confidence AS confidence, p.source AS source
        "#, &params).await?;

        if let Some(row) = page.rows.first() {
            return Ok(Some(Answer {
                value: row.get("answer").unwrap().as_string()?,
                confidence: row.get("confidence").unwrap().as_float()?,
                source: row.get("source").unwrap().as_string()?,
                explanation: Some(format!("{} founded {}",
                    row.get("answer").unwrap().as_string()?, org_name)),
            }));
        }
    }

    Ok(None)
}

interface Answer {
  value: string;
  confidence: number;
  source: string;
  explanation?: string;
}

async function answerQuestion(client: Client, question: string): Promise<Answer | null> {
  // Pattern: "Where was X born?"
  const bornMatch = question.match(/[Ww]here was (.+?) born\??/);
  if (bornMatch) {
    const entityName = bornMatch[1];
    const rows = await client.queryAll(`
      MATCH (p:Person {name: $name})-[:BORN_IN]->(location:Location)
      RETURN location.name AS answer, p.confidence AS confidence, p.source AS source
    `, { params: { name: entityName } });

    if (rows.length > 0) {
      const row = rows[0];
      return {
        value: row.get('answer')?.asString ?? '',
        confidence: row.get('confidence')?.asNumber ?? 0,
        source: row.get('source')?.asString ?? '',
        explanation: `${entityName} was born in ${row.get('answer')?.asString}`
      };
    }
  }

  // Pattern: "Who founded X?"
  const foundedMatch = question.match(/[Ww]ho founded (.+?)\??/);
  if (foundedMatch) {
    const orgName = foundedMatch[1];
    const rows = await client.queryAll(`
      MATCH (p:Person)-[:FOUNDED]->(org:Organization {name: $name})
      RETURN p.name AS answer, p.confidence AS confidence, p.source AS source
    `, { params: { name: orgName } });

    if (rows.length > 0) {
      const row = rows[0];
      return {
        value: row.get('answer')?.asString ?? '',
        confidence: row.get('confidence')?.asNumber ?? 0,
        source: row.get('source')?.asString ?? '',
        explanation: `${row.get('answer')?.asString} founded ${orgName}`
      };
    }
  }

  return null;
}

const Answer = struct {
    value: []const u8,
    confidence: f64,
    source: []const u8,
    explanation: ?[]const u8,
};

pub fn answerQuestion(
    client: *geode.GeodeClient,
    allocator: std.mem.Allocator,
    question: []const u8,
) !?Answer {
    // Pattern matching for "Where was X born?"
    if (std.mem.indexOf(u8, question, "born")) |_| {
        // Extract entity name (simplified)
        const entity_name = extractEntityName(question);

        var params = std.json.ObjectMap.init(allocator);
        defer params.deinit();
        try params.put("name", .{ .string = entity_name });

        try client.sendRunGql(1,
            \\MATCH (p:Person {name: $name})-[:BORN_IN]->(location:Location)
            \\RETURN location.name AS answer, p.confidence AS confidence, p.source AS source
        , .{ .object = params });

        _ = try client.receiveMessage(30000);
        try client.sendPull(1, 1);
        const result = try client.receiveMessage(30000);
        defer allocator.free(result);

        // Parse result and return Answer
        // ...
    }

    return null;
}