mkdir -p ~/curiosity/first-app
ADMIN_PASSWORD=$(openssl rand -base64 24)
docker run --name first-app \
  -p 127.0.0.1:8080:8080 \
  -v ~/curiosity/first-app:/data \
  -e MSK_GRAPH_STORAGE=/data/curiosity \
  -e MSK_ADMIN_PASSWORD="$ADMIN_PASSWORD" \
  curiosityai/curiosity:latest
echo "Admin password: $ADMIN_PASSWORD"

Customer ──HasTicket──▶ Ticket ──ForProduct──▶ Product
                          │
                          ├──MentionsEntity──▶ Entity   (NLP-extracted)
                          └──HasStatus──▶ Status

dotnet new console -n FirstApp.Connector
cd FirstApp.Connector
dotnet add package Curiosity.Library

using Curiosity.Library;

[Node]
public class Customer
{
    [Key] public string Id { get; set; }
    [Property] public string Name { get; set; }
    [Property] public string Tier { get; set; }     // "Free" | "Pro" | "Enterprise"
}

[Node]
public class Product
{
    [Key] public string Sku { get; set; }
    [Property] public string Name { get; set; }
}

[Node]
public class Status
{
    [Key] public string Code { get; set; }          // "Open" | "Pending" | "Resolved"
    [Property] public string Label { get; set; }
}

[Node]
public class Ticket
{
    [Key] public string Id { get; set; }
    [Property] public string Subject { get; set; }
    [Property] public string Body { get; set; }     // long text — we'll embed this
    [Timestamp] public DateTimeOffset CreatedAt { get; set; }
}

public static class Edges
{
    public const string HasTicket   = nameof(HasTicket);
    public const string TicketOf    = nameof(TicketOf);
    public const string ForProduct  = nameof(ForProduct);
    public const string HasStatus   = nameof(HasStatus);
}

using var workspace = await Workspace.ConnectAsync(
    baseUrl: Environment.GetEnvironmentVariable("WORKSPACE_URL") ?? "http://localhost:8080",
    apiToken: Environment.GetEnvironmentVariable("WORKSPACE_TOKEN"));

var graph = workspace.Graph;

// 1) Register schemas (idempotent)
await graph.CreateNodeSchemaAsync<Customer>();
await graph.CreateNodeSchemaAsync<Product>();
await graph.CreateNodeSchemaAsync<Status>();
await graph.CreateNodeSchemaAsync<Ticket>();
await graph.CreateEdgeSchemaAsync(typeof(Edges));

// 2) Reference data
var statusOpen     = graph.TryAdd(new Status { Code = "Open",     Label = "Open" });
var statusResolved = graph.TryAdd(new Status { Code = "Resolved", Label = "Resolved" });
var enterprise     = await graph.CreateTeamAsync("Enterprise Support", "Enterprise customers");

// 3) Stream source records → graph
foreach (var row in LoadTicketsFromCsv("tickets.csv"))
{
    var customer = graph.TryAdd(new Customer { Id = row.CustomerId, Name = row.CustomerName, Tier = row.Tier });
    var product  = graph.TryAdd(new Product  { Sku = row.Sku,        Name = row.ProductName });
    var status   = row.Status == "Resolved" ? statusResolved : statusOpen;

    var ticket = graph.TryAdd(new Ticket {
        Id        = row.TicketId,
        Subject   = row.Subject,
        Body      = row.Body,
        CreatedAt = row.CreatedAt,
    });

    graph.Link(customer, ticket,  Edges.HasTicket, Edges.TicketOf);
    graph.Link(ticket,   product, Edges.ForProduct);
    graph.Link(ticket,   status,  Edges.HasStatus);

    // Restrict Enterprise-tier tickets to the Enterprise team
    if (row.Tier == "Enterprise")
        graph.RestrictAccessToTeam(ticket, enterprise);
}

await graph.CommitPendingAsync();

export WORKSPACE_TOKEN="<the token you created>"
dotnet run

class SimilarTicketsRequest
{
    public string Query        { get; set; }   // user's text
    public string ProductSku   { get; set; }   // optional scope
    public int    Limit        { get; set; } = 10;
}

var req = Body.FromJson<SimilarTicketsRequest>();
if (string.IsNullOrWhiteSpace(req.Query))
    return BadRequest("query is required");

var search = SearchRequest.For(req.Query);
search.BeforeTypesFacet = new([] { nameof(Ticket) });

if (!string.IsNullOrWhiteSpace(req.ProductSku))
{
    search.TargetUIDs = Q().StartAt(nameof(Product), req.ProductSku)
                           .In(Edges.ForProduct)
                           .AsUIDEnumerable()
                           .ToArray();
}

// Permission-aware: runs in the calling user's security context
var query = await Graph.CreateSearchAsUserAsync(search, CurrentUser, CancellationToken);
return query.Take(req.Limit).Emit("N");

curl -X POST "http://localhost:8080/api/endpoints/run/similar-tickets" \
  -H "Authorization: Bearer $WORKSPACE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "query": "screen flicker after firmware update", "limit": 5 }'

public class TicketTools
{
    [Tool("Search the support-ticket knowledge base for tickets similar to the user's question. " +
          "Use this whenever the user asks 'have we seen this before?' or describes a symptom. " +
          "Cite results with the bracketed snippet id, e.g. [1].")]
    public static async Task<string> FindSimilarTickets(ToolScope scope,
        [Parameter("The symptom or question, in the user's own words", required: true)] string query,
        [Parameter("Optional product SKU to scope the search", required: false)] string productSku,
        [Parameter("Max results", required: false)] int limit)
    {
        var search = SearchRequest.For(query);
        search.BeforeTypesFacet = new([] { nameof(Ticket) });

        if (!string.IsNullOrWhiteSpace(productSku))
            search.TargetUIDs = scope.Graph.Q()
                .StartAt(nameof(Product), productSku)
                .In(Edges.ForProduct)
                .AsUIDEnumerable()
                .ToArray();

        var q = await scope.Graph.CreateSearchAsUserAsync(search, scope.CurrentUser, scope.CancellationToken);
        var results = q.Take(limit > 0 ? limit : 10).AsEnumerable().Select(n =>
        {
            var text = scope.ChatAI.GetTextFromNode(n.UID, limit: 4_000);
            var snippetId = scope.AddSnippet(uid: n.UID, text: text);
            return new {
                snippetId,
                ticketId = n.GetString(nameof(Ticket.Id)),
                subject  = n.GetString(nameof(Ticket.Subject)),
                body     = text,
            };
        }).ToArray();

        scope.SetToolCallDisplayName($"Looked for tickets similar to '{query}'");
        return results.ToJson();
    }
}
return new TicketTools();