toolnexus

Point it at your tools. Get a working agent.

Point toolnexus at an mcp.json and a skills/ folder and you get the tool-calling loop, skills injection, six unified tool sources, and conversation memory — all included. The same three lines, in every language:

JavaScript

import { createToolkit, createClient } from "toolnexus"

const tk = await createToolkit({
  mcpConfig: "./mcp.json",                           // every MCP server's tools
  skillsDir: "./skills",                             // every SKILL.md, loaded on demand
})
const agent = createClient({
  baseUrl: "https://openrouter.ai/api/v1",          // any OpenAI- or Anthropic-style endpoint
  style: "openai",
  model: "openai/gpt-4o-mini",
})

const { text } = await agent.run("Use my tools to answer this.", { toolkit: tk })
console.log(text)

Python

import asyncio
from toolnexus import create_toolkit, create_client

async def main():
    tk = await create_toolkit(
        mcp_config="./mcp.json",                     # every MCP server's tools
        skills_dir="./skills",                       # every SKILL.md, loaded on demand
    )
    agent = create_client(
        base_url="https://openrouter.ai/api/v1", style="openai",
        model="deepseek/deepseek-chat",
    )
    res = await agent.run("Use my tools to answer this.", tk)
    print(res.text)
    await tk.close()

asyncio.run(main())

Go

package main

import (
  "context"
  "fmt"

  "github.com/muthuishere/toolnexus/golang"
)

func main() {
  ctx := context.Background()
  tk, _ := toolnexus.CreateToolkit(ctx, toolnexus.Options{
    MCPConfig: "./mcp.json", // every MCP server's tools
    SkillsDir: "./skills",   // every SKILL.md, loaded on demand
  })
  defer tk.Close()

  agent := toolnexus.CreateClient(toolnexus.ClientOptions{
    BaseURL: "https://openrouter.ai/api/v1",
    Style:   "openai",
    Model:   "openai/gpt-4o-mini",
  })

  res, _ := agent.Run(ctx, "Use my tools to answer this.", tk)
  fmt.Println(res.Text)
}

Java

Toolkit tk = Toolkit.create(new Toolkit.Options()
        .mcpConfig("./mcp.json")     // every MCP server's tools
        .skillsDir("./skills"));     // every SKILL.md, loaded on demand
LlmClient agent = LlmClient.create(new LlmClient.Options()
        .baseUrl("https://openrouter.ai/api/v1")
        .style("openai")
        .model("openai/gpt-4o-mini"));
System.out.println(agent.run("Use my tools to answer this.", tk).text);

C#

using Toolnexus;

await using var tk = await Toolkit.CreateAsync(new Toolkit.Options
{
    McpConfig = "./mcp.json",   // every MCP server's tools
    SkillsDir = "./skills",     // every SKILL.md, loaded on demand
});
var agent = LlmClient.Create(new LlmClient.Options
{
    BaseUrl = "https://openrouter.ai/api/v1",
    Style   = "openai",
    Model   = "anthropic/claude-3.5-sonnet",
    ApiKey  = Environment.GetEnvironmentVariable("OPENROUTER_API_KEY"),
});

var res = await agent.RunAsync("Use my tools to answer this.", tk);
Console.WriteLine(res.Text);

Elixir

{:ok, tk} =
  Toolnexus.create_toolkit(
    mcp_config: "./mcp.json",                    # every MCP server's tools
    skills_dir: "./skills"                       # every SKILL.md, loaded on demand
  )

agent =
  Toolnexus.Client.create(
    base_url: "https://openrouter.ai/api/v1",    # any OpenAI- or Anthropic-style endpoint
    style: "openai",
    model: "openai/gpt-4o-mini"
  )

res = Toolnexus.Client.run(agent, "Use my tools to answer this.", tk)
IO.puts(res.text)

Clojure

(require '[toolnexus.core :as tn] '[toolnexus.client :as client])

(def tk (tn/build {:mcp    "./mcp.json"      ; every MCP server's tools
                   :skills "./skills"}))     ; every SKILL.md, loaded on demand

(def agent
  (client/create-client
    {:base-url "https://openrouter.ai/api/v1" ; any OpenAI- or Anthropic-style endpoint
     :style    "openai"
     :model    "openai/gpt-4o-mini"}))

(println (:text (client/run agent "Use my tools to answer this." {:toolkit tk})))

One interface for every tool

MCP servers

Read an mcp.json, connect to every server (local stdio + remote streamable-HTTP), expose each server tool as a uniform Tool.

Agent skills

Glob a skills/ folder of SKILL.md files; one skill tool loads instructions and resources on demand — progressive disclosure.

Your own functions

Register a plain function as a tool. Native, HTTP endpoints, and the built-in shell/file tools all share the same shape.

Remote A2A agents

Another agent, called like a function. toolkit.serve(...) also exposes your toolkit to the world as an A2A agent.

The loop, included

System prompt, skills injection, parallel + chained tool calls, hooks, streaming, retries, conversation memory, observability metrics.

Human in the loop

The suspension layer: an agent can pause, ask you a question, and resume — plus an MCP elicitation bridge. Nobody else ships this across six ports.

Byte-identical across seven languages

The whole point is parity: the same examples/ fixtures produce the same behavior in every language — all seven published to their registries. Clojure is one .cljc tree that runs on the JVM and on cljgo, wired into the same conformance checker at the same full tier, agent layer included. Install for yours on the install page, or start with the quickstart.