Welcome to Nexmon API Documentation

import { createAgent, z } from "nexmon";

// 1. Initialize Agent with instructions and response schema
const agent = createAgent({
  name: "CodeReviewAgent",
  instructions: "Analyze input code snippet and produce structured JSON audit report.",
  responseSchema: z.object({
    issueCount: z.number(),
    severity: z.enum(["LOW", "MEDIUM", "HIGH"]),
    summary: z.string()
  })
});

// 2. Multi-turn chat maintains state across turns out of the box!
await agent.chat("Analyzing src/index.ts file...");
const result = await agent.chat("Generate final structured review report");

// Strongly typed validated object parsed automatically
console.log("Structured Output:", result.structuredOutput);

import { createAgent, OpenAICompatProvider } from "nexmon";

// Connect to local Ollama inference engine or custom vLLM gateway
const localProvider = new OpenAICompatProvider({
  baseUrl: process.env.NEXMON_BASE_URL || "http://localhost:11434/v1",
  apiKey: process.env.NEXMON_API_KEY || "ollama",
  model: "llama3.2",
  defaultHeaders: { "X-Environment": "Local-Inference" }
});

const agent = createAgent({
  name: "LocalLLMAgent",
  provider: localProvider,
  instructions: "Perform zero-cost local LLM inference!"
});

const response = await agent.run("Summarize key benefits of local LLM deployment.");
console.log("Local Output:", response.text);

import { createAgent, defineTool, z } from "nexmon";

// 1. Declare high-risk tool requiring human approval for production tables
const deleteDatabaseTool = defineTool({
  name: "deleteDatabaseTable",
  description: "Deletes a database table irreversibly",
  schema: z.object({ tableName: z.string() }),
  riskLevel: "CRITICAL",
  requiresApproval: ({ tableName }) => tableName.startsWith("prod_"),
  handler: async ({ tableName }) => ({ status: "deleted", table: tableName })
});

// 2. Attach approval handler callback to intercept execution safely
const agent = createAgent({
  name: "DBAdminAgent",
  tools: [deleteDatabaseTool],
  onApprovalRequest: async (request) => {
    console.log(`⚠️ Approval Requested for tool: ${request.toolName}`, request.input);
    // Human reviews request and returns approval decision
    return { approved: true };
  }
});

await agent.run("Drop table prod_users");

import { createAgent, createVectorStore, ShortTermMemory } from "nexmon";

// 1. Zero-code Env Controlled Setup (driven by .env file):
// NEXMON_VECTOR_STORE_TYPE="mem0"
// NEXMON_MEM0_API_KEY="m0-xxx"
// NEXMON_MEM0_URL="https://api.mem0.ai/v1"
// NEXMON_MEM0_USER_ID="user_101"

const envDrivenStore = createVectorStore(); // Auto-reads NEXMON_VECTOR_STORE_TYPE

// 2. Explicit Factory Setup for Mem0 / PGVector / Qdrant:
const mem0Store = createVectorStore({
  type: "mem0",
  apiKey: process.env.NEXMON_MEM0_API_KEY,
  url: "https://api.mem0.ai/v1"
});

const agent = createAgent({
  name: "EnvMemoryAgent",
  shortTermMemory: new ShortTermMemory({ maxMessages: 20 }),
  vectorStore: envDrivenStore
});

await agent.remember("User preference: Always return JSON format.");
const facts = await agent.recall("User preference");

import { createAgent, EventBus, replayAgentState } from "nexmon";

// 1. Subscribe to real-time execution event bus stream
const eventBus = new EventBus();
eventBus.on("event", (evt) => {
  console.log(`[EVENT ${evt.timestamp}] Type: ${evt.type}`, evt.payload);
});

const agent = createAgent({ name: "AuditedAgent", eventBus });
const result = await agent.run("Execute financial order #8841");

// 2. Reconstruct deterministic state up to step 2 for audit debugging
const historicalEvents = result.messages; // or agent.getEventLog()
const reconstructedState = replayAgentState(historicalEvents, 2);
console.log("Reconstructed Step 2 State:", reconstructedState);

import { createAgent, SubAgentFleet } from "nexmon";

// 1. Initialize specialized worker agents
const researcher = createAgent({ name: "Researcher", instructions: "Gathers raw facts and technical metrics." });
const writer = createAgent({ name: "Writer", instructions: "Synthesizes clear prose reports." });

// 2. Wrap under supervisor agent inside a SubAgentFleet
const fleet = new SubAgentFleet({
  supervisor: createAgent({ name: "Editor", instructions: "Coordinates team output." }),
  workers: [researcher, writer]
});

// 3. Delegate complex task to fleet
const fleetOutput = await fleet.execute("Write a comprehensive research report on quantum AI.");
console.log("Fleet Final Output:", fleetOutput.text);

import { createAgent, DocumentLoader, VectorIndex } from "nexmon";

// 1. Load and parse PDF document into text chunks
const loader = new DocumentLoader();
const pdfDoc = await loader.loadPDF("./system-manual.pdf");

// 2. Index text chunks into similarity vector store
const vectorIndex = new VectorIndex();
await vectorIndex.addDocuments(pdfDoc.chunks);

// 3. Attach vector store to Agent for document RAG querying
const ragAgent = createAgent({
  name: "PDFDocAssistant",
  vectorStore: vectorIndex,
  instructions: "Answer queries accurately based strictly on loaded document context."
});

const answer = await ragAgent.run("What are the hardware memory prerequisites?");
console.log("RAG Answer:", answer.text);

import { createAgent, TelemetryManager, SecurityGuardrail } from "nexmon";

// 1. Configure OpenTelemetry tracing exporter
const telemetry = new TelemetryManager({
  serviceName: "nexmon-production-agent",
  exportEndpoint: "http://localhost:4318/v1/traces"
});

// 2. Configure runtime security guardrail (PII redaction + injection filter)
const guardrail = new SecurityGuardrail({
  blockPromptInjection: true,
  redactPII: true,
  customRules: [(input) => !input.includes("DROP DATABASE")]
});

// 3. Instantiate hardened agent
const secureAgent = createAgent({
  name: "HardenedEnterpriseAgent",
  telemetry,
  guardrails: [guardrail]
});

await secureAgent.run("Process inquiry for john.doe@example.com");

import { createAgent, MCPClient, StdioMCPTransport, getToolsFromMCPClient, exportAgentAsMCPServer } from "nexmon";

// 1. Create Stdio transport connecting to external filesystem MCP server
const transport = new StdioMCPTransport({
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-filesystem", "./data"]
});

// 2. Connect MCP Client & discover tools automatically
const mcpClient = new MCPClient(transport, { name: "filesystem_mcp" });
await mcpClient.connect();
const mcpTools = await getToolsFromMCPClient(mcpClient);

// 3. Create Agent equipped with external MCP server tools!
const agent = createAgent({
  name: "FilesystemAgent",
  instructions: "Inspect and update files using external MCP tools.",
  tools: mcpTools
});

const result = await agent.run("List files in ./data and check their status.");
console.log(result.text);

await mcpClient.disconnect();

// Optional: Export Nexmon Agent as an MCP Server for Claude Desktop / Cursor
const mcpServer = exportAgentAsMCPServer(agent, { name: "exported_agent", version: "1.0.0" });
await mcpServer.startStdio();

import { createAgent, defineTool, httpFetchTool, codeInterpreterTool, z } from "nexmon";

// 1. Define custom application tool with Zod parameters & context injection
const searchUserDbTool = defineTool({
  name: "search_users",
  description: "Search user database by status",
  parameters: z.object({ status: z.enum(["active", "pending"]) }),
  execute: async ({ status }, context) => {
    return { status, count: 42, requestedBy: context?.context?.userId };
  }
});

// 2. Attach custom & built-in tools to agent
const agent = createAgent({
  name: "ToolingAgent",
  tools: [searchUserDbTool, httpFetchTool, codeInterpreterTool]
});

const result = await agent.run("Search active users and check HTTP status of api.example.com");
console.log(result.text);