// 1. Create a knowledge graph instance
const graph = new NeuledgeGraph();

// 2. Pass the lookup tool to your AI agent
const agent = new Agent({
  tools: { lookup: tool(graph.lookup) },
});

// 3. Ask questions - the agent will fetch live data automatically
const { text } = await agent.generate({
  prompt: 'What is the weather in San Francisco?',
});

// => "San Francisco is sunny, about 68°F."

import { anthropic } from "@ai-sdk/anthropic";
import { NeuledgeGraph } from "@neuledge/graph";
import { stepCountIs, ToolLoopAgent, tool } from "ai";

const graph = new NeuledgeGraph();

const agent = new ToolLoopAgent({
  model: anthropic("claude-sonnet-4-5"),
  tools: {
    lookup: tool(graph.lookup),
  },
  stopWhen: stepCountIs(20),
});

const { textStream } = await agent.stream({
  prompt: "Compare Apple and Microsoft stock prices",
});

for await (const textPart of textStream) {
  process.stdout.write(textPart);
}
process.stdout.write("\n");

import { NeuledgeGraph } from "@neuledge/graph";
import { Agent, run, tool } from "@openai/agents";

const graph = new NeuledgeGraph();

const agent = new Agent({
  name: "Data Assistant",
  model: "gpt-4.1",
  tools: [tool(graph.lookup)],
});

const result = await run(agent, "What is the current price of Apple stock?");
console.log(result);

// make sure to install all the following packages:
// $ npm install @neuledge/graph langchain @langchain/openai @langchain/core zod zod-to-json-schema

import { NeuledgeGraph } from "@neuledge/graph";
import { createAgent, tool } from "langchain";

// Create the tool from the graph lookup function
const graph = new NeuledgeGraph();

const lookup = tool(graph.lookup, graph.lookup);

// Create the agent with an OpenAI LLM
const agent = createAgent({
  model: "openai:gpt-4.1",
  tools: [lookup],
});

// Invoke the agent
const result = await agent.invoke({
  messages: [
    { role: "user", content: "What is the exchange rate from USD to EUR?" },
  ],
});
console.log(result);

import "dotenv/config";
import { NeuledgeGraph } from '@neuledge/graph';

const graph = new NeuledgeGraph({
  apiKey: process.env.NEULEDGE_API_KEY
});

// Install: npm install @neuledge/graph-router @neuledge/graph-memory-registry fastify
import { NeuledgeGraphRouter } from "@neuledge/graph-router";
import { NeuledgeGraphMemoryRegistry } from "@neuledge/graph-memory-registry";
import { openai } from "ai";
import Fastify from "fastify";

// Create registry with embedding model
const registry = new NeuledgeGraphMemoryRegistry({
  model: openai.embedding("text-embedding-3-small"),
});

// Register your data sources
await registry.register({
  template: "cities.{city}.weather",
  resolver: async (match) => {
    const city = match.params.city;
    const response = await fetch(`https://api.weather.com/current?city=${city}`);
    return response.json();
  },
});

// Create router
const router = new NeuledgeGraphRouter({ registry });

// Set up HTTP server
const app = Fastify();

app.post("/lookup", async (request, reply) => {
  const result = await router.lookup(request.body);
  return reply.send(result);
});

app.listen({ port: 3000 });

import { NeuledgeGraph } from "@neuledge/graph";

// Connect to your custom server
const graph = new NeuledgeGraph({
  baseUrl: "http://localhost:3000",
});

// Use it the same way as with the default server
const result = await graph.lookup({ query: "cities.tokyo.weather" });
console.log(result); // => { status: "matched", match: {...}, value: {...} }

interface NeuledgeGraphOptions {
  apiKey?: string;        // Your API key (optional for free tier)
  baseUrl?: string;       // Custom API endpoint (optional)
  timeout?: number;       // Request timeout in ms (default: 10000)
}

const graph = new NeuledgeGraph({
  apiKey: process.env.NEULEDGE_API_KEY,
  timeout: 5000,
});