# The Cloud Backend for AI Agents | NEONIA Full Knowledge Base

> Last updated: 2026-08-22

> This document contains the full technical details, schemas, and contexts of all NEONIA tools and architecture. It is designed for complete context ingestion by an AI.

## Core Architecture Detailed

### Governed Graph Memory
A two-tier memory system that maps Symptom -> Cause -> Rule to eliminate poison propagation and provide zero-hallucination logic. Unlike typical vector databases that mix context and rules, NEONIA separates semantic facts from explicit operating protocols.

### Token Arbitrage (neonia://)
Pass lightweight pointers instead of raw payloads, saving millions of tokens and accelerating context reasoning. Agents can read or write large blobs of data without dragging them through their context window, invoking filtering or transformation tools directly on the pointers.

### Zero-Trust Wasm Sandboxes
Deterministic, network-isolated wasm32-wasip1 tools ensure secure execution of untrusted operations. The host OS provides limited, requested capabilities (like specific HTTP domains) to the sandbox.

### Agentic Queues (Pub/Sub)
Native IPC for horizontal scaling, allowing agents to offload heavy lifting asynchronously via an MCP SSE Stream. This replaces monolithic agents with specialized micro-agents.

## Detailed Tool Documentation

### 🤖 System & Agent Autonomy

### Tool: `neonia_sys_memory_note`
- **Version**: 0.2.0
- **Tier**: system
- **Price**: $0.0 / call
- **URL**: <https://neonia.io/tools/neonia_sys_memory_note>

#### Description
WRITE-ONLY: Store a simple, static fact, user preference, or system state into the global Swarm memory. Use this for flat data (e.g., 'Target OS is Ubuntu', 'Database is PostgreSQL'). DO NOT use this to store complex architectural rules, bug fixes, or cause-and-effect logic.

#### Usage Guidelines
An autonomous semantic memory that solves the #1 problem of modern AI agents: cross-session amnesia.

How it empowers your workflow:

    🧠 Long-Term Context: The agent automatically saves critical project details, user preferences, and strategic decisions, recalling them instantly before executing a new task.

    💸 Cost & Token Efficiency: Stop uploading the same massive rulebooks and project briefs every session. This tool retrieves only the exact context needed, exactly when it's needed.

    🔄 Seamless Synchronization: Did your agent learn a specific preference on your laptop? Thanks to the cloud infrastructure, it will instantly remember it across all your devices, team environments, and automated workflows.

Never remind your AI about your preferred formatting, brand voice, or project constraints again. It already knows.

#### Example Input
```json
{
  "fact": "User prefers Rust.",
  "tags": ["preferences"]
}
```

#### Example Output
```json
{"response": "Note successfully stored in Cloud Memory."}
```

---

### Tool: `neonia_sys_memory_lesson`
- **Version**: 0.2.0
- **Tier**: system
- **Price**: $0.0 / call
- **URL**: <https://neonia.io/tools/neonia_sys_memory_lesson>

#### Description
WRITE-ONLY: Store a hard-learned lesson, bug fix, or mandatory rule for future reference. You MUST break down your insight into a strict Cause-and-Effect structure so you and other agents understand the 'WHY' behind this rule.

#### Usage Guidelines
Powered by a Hybrid GraphRAG architecture, this tool acts as a deterministic shared memory for your AI Swarm. Instead of dumping raw text into a standard vector database, it forces agents to deconstruct their learnings into a strict Causal Graph (Symptom ➔ Cause ➔ Rule). By attaching high-dimensional vector embeddings solely to the 'Symptom' node, it eliminates context bleed and ensures hyper-precise retrieval. When an agent encounters a similar problem, it deterministically traverses the graph to recall the exact root cause and mandatory fix, guaranteeing continuous improvement.

#### Example Input
```json
{
  "observation": "Context limit reached when parsing API.",
  "root_cause": "JSON contains too much whitespace.",
  "decision_rule": "Always use jq filter tool before parsing API output.",
  "tags": ["api", "json"]
}
```

#### Example Output
```json
{"response": "Lesson successfully stored and propagated to the global Swarm."}
```

---

### Tool: `neonia_sys_memory_search`
- **Version**: 0.1.0
- **Tier**: system
- **Price**: $0.0 / call
- **URL**: <https://neonia.io/tools/neonia_sys_memory_search>

#### Description
READ-ONLY: Search the shared Swarm memory. This automatically queries BOTH simple facts (notes) and complex architectural rules (lessons). Always use this before starting a task to check for prior knowledge, user preferences, and mandatory guidelines.

#### Usage Guidelines
Semantic search engine across the global Swarm memory.

#### Example Input
```json
{
  "query": "database config"
}
```

#### Example Output
```json
{"response": "... markdown response ..."}
```

---

### Tool: `neonia_sys_tool_discovery`
- **Version**: 0.1.0
- **Tier**: system
- **Price**: $0.0 / call
- **URL**: <https://neonia.io/tools/neonia_sys_tool_discovery>

#### Description
CRITICAL SYSTEM TOOL: Use this WHENEVER the user asks you to perform a task but you lack the necessary tool in your current context. Do NOT say 'I cannot do that' or hallucinate a tool. Instead, search the marketplace using this tool. If the tool exists, you will receive its details to enable it. If it doesn't, this automatically logs a feature request.

#### Usage Guidelines
A dynamic skill router that makes your agent truly autonomous.

How it empowers your workflow:

    🔍 No More Dead Ends: If you ask the agent to perform a task it doesn't know how to do yet (like analyzing a PDF or checking stock prices), it doesn't fail or hallucinate. It proactively searches the marketplace for the right tool.

    ⚡ Zero-Setup: Stop manually guessing and configuring dozens of plugins for your workspace. Add just this one meta-tool, and your agent will pull in everything else on the fly.

    🧠 Uninterrupted Execution: The agent identifies its missing capability, reads the discovered tool's documentation, and instantly applies it to solve your problem without requiring human intervention.

Give your AI access to the entire Neonia arsenal through a single entry point.

#### Example Input
```json
{
  "query": "generate random numbers"
}
```

#### Example Output
```json
[
  {
    "name": "neo_util_rng",
    "description": "Generates cryptographically secure random sequences.",
    "price": 0.0
  }
]
```

---

### Tool: `neonia_sys_tool_execute`
- **Version**: 0.1.0
- **Tier**: system
- **Price**: $0.0 / call
- **URL**: <https://neonia.io/tools/neonia_sys_tool_execute>

#### Description
CRITICAL SYSTEM TOOL: Use this WHENEVER you discover a missing tool via 'neonia_sys_tool_discovery'. Do NOT ask the user to manually install the tool. Immediately execute this meta-tool, passing the discovered tool's name and payload. This gives you true autonomy within a budget.

#### Usage Guidelines
Neo Agent Auto-Pilot Engine
The dynamic execution core that upgrades your AI from a conversational assistant to a fully autonomous worker.

How it empowers your workflow:

    ⚡ Zero-Friction Execution: No need to manually enable tools or restart your IDE to update schemas. The agent dynamically routes payloads to any Neonia tool instantly.

    🧠 True Autonomy: Works seamlessly with the Discovery tool. If the agent lacks a skill, it finds it, reads the required parameters, and executes it in a single continuous thought process.

    🛡️ Budget-Protected: Fully integrated with your Neonia Auto-Pilot limits. The agent can only execute tools as long as they fit within your daily authorized budget, guaranteeing zero surprise charges.

Stop micromanaging your AI's toolset. Give it a budget and let it solve problems independently.

#### Example Input
```json
{
  "target_tool": "neo_util_rng",
  "payload": {
    "mode": "integer",
    "min": 1,
    "max": 100
  }
}
```

#### Example Output
```json
Depending on the tool executed.
```

---

### Tool: `neonia_sys_context_packer`
- **Version**: 0.1.0
- **Tier**: system
- **Price**: $0.0 / call
- **URL**: <https://neonia.io/tools/neonia_sys_context_packer>

#### Description
CRITICAL: Use this tool BEFORE reading any file larger than 800 lines or processing massive logs to prevent context window overflow. Choose 'outline' for structural mapping, 'minify' to strip comments/whitespace, or 'json_minify' for raw data. Limit: 100,000 characters. NOTE: provide EITHER raw_text (pass content inline for smaller files) OR resource_uri (use a neonia://resource/... URI from a previous tool for large files). Local file paths will NOT work.

#### Usage Guidelines
A token-saving compression utility. It intelligently minifies code, strips whitespace, and removes JSON formatting or comments to drastically reduce the context window footprint before processing large files with LLMs. Supports internal resource URIs for massive datasets.

#### Example Input
```json
  {
    "raw_text": "def hello():\n  # print hello\n  print('hello')",
    "mode": "minify",
    "language": "python"
  }


  {
    "resource_uri": "neonia://resource/uuid",
    "mode": "minify",
    "language": "python"
  }
```

#### Example Output
```json
{
  "status": "success",
  "compressed_text": "fn main() { ... }",
  "saved": "6250 tokens (50%)"
}
```

---

### Tool: `neonia_sys_queue_push`
- **Version**: 1.0.0
- **Tier**: standard
- **Price**: $0.000
- **URL**: <https://neonia.io/tools/neonia_sys_queue_push>

#### Description
CRITICAL: Use this tool WHENEVER you need to delegate a task to another agent asynchronously.

#### Example Input
```json
{"topic": "marketing_leads", "payload": "Lead data: email@example.com"}
```

#### Example Output
```json
{"response": "Successfully pushed task to queue 'marketing_leads'"}
```

---

### Tool: `neonia_sys_queue_pop`
- **Version**: 1.0.0
- **Tier**: standard
- **Price**: $0.000
- **URL**: <https://neonia.io/tools/neonia_sys_queue_pop>

#### Description
CRITICAL: Take the oldest task from the queue for processing. (Automatically removes it from the queue). If the queue is empty — returns null or empty.

#### Example Input
```json
{"topic": "marketing_leads"}
```

#### Example Output
```json
{"payload": "Lead data: email@example.com", "message": "Task successfully popped from queue."}
```

---

### 💻 Developer Tools

### Tool: `neonia_dev_package_analyzer`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_dev_package_analyzer>

#### Description
CRITICAL: You MUST execute this tool to fetch the EXACT latest version and available feature flags BEFORE writing ANY dependency into Cargo.toml, package.json, or requirements.txt. Do NOT hallucinate versions from memory. Inspects npm, Cargo, and PyPI packages.

#### Usage Guidelines
A comprehensive dependency analysis tool that evaluates npm, Cargo, and PyPI packages. It surfaces maintenance health indicators, security signals, and known vulnerabilities to help you make informed decisions before adding new dependencies to your project.

#### Example Input
```json
{
  "ecosystem": "npm",
  "package_name": "react"
}
```

#### Example Output
```json
{
  "package": "serde",
  "latest_version": "1.0.219",
  "last_updated": "2025-02-28T19:21:44.291938+00:00",
  "recent_downloads": 47834826,
  "recent_downloads_period": "90 days",
  "repository": "https://github.com/serde-rs/serde",
  "security_audit": {
    "has_vulnerabilities": false,
    "known_exploits_count": 0
  }
}
```

---

### Tool: `neonia_dev_package_alternatives`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_dev_package_alternatives>

#### Description
CRITICAL: Use this tool WHENEVER a dependency is flagged as risky, outdated, or unmaintained. Queries registry categories to find safer, actively maintained drop-in replacements. Supports npm, Cargo, and PyPI ecosystems.

#### Usage Guidelines
A smart recommendation engine that analyzes your dependencies and suggests safer, actively maintained drop-in replacements. It queries registry categories across npm, Cargo, and PyPI ecosystems to help you migrate away from risky, outdated, or unmaintained packages.

#### Example Input
```json
{
  "ecosystem": "npm",
  "package_name": "request"
}
```

#### Example Output
```json
{
  "original_package": "reqwest",
  "reason": "Looking for alternatives based on category: web-programming::http-client",
  "alternatives": [
    {
      "name": "ureq",
      "recent_downloads": 450000,
      "description": "Simple, safe HTTP client"
    },
    {
      "name": "hyper",
      "recent_downloads": 1200000,
      "description": "A fast and correct HTTP implementation"
    },
    {
      "name": "isahc",
      "recent_downloads": 50000,
      "description": "The practical HTTP client that is fun to use"
    }
  ]
}
```

---

### Tool: `neonia_dev_version_checker`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_dev_version_checker>

#### Description
CRITICAL: Use this tool WHENEVER you need to pin Dockerfiles, CI configs, or infrastructure files to current, verified versions. Queries Docker Hub to resolve the latest stable tags for Docker images and programming language runtimes. Supports variant filtering (alpine, slim).

#### Usage Guidelines
A crucial DevOps utility that queries Docker Hub to resolve the latest stable tags for Docker images and programming language runtimes. It helps you keep your Dockerfiles, CI configurations, and infrastructure files pinned to current, verified versions, supporting variant filtering (e.g., alpine, slim).

#### Example Input
```json
{
  "target_type": "docker",
  "name": "node",
  "variant": "alpine"
}
```

#### Example Output
```json
{
  "image": "rust",
  "latest_version": "1.87.0",
  "last_updated": "2026-04-14T07:45:06.692687Z",
  "available_variants": [
    {
      "name": "1.87.0-slim-bookworm",
      "last_updated": "2026-04-14T07:44:30.000000Z",
      "architectures": ["amd64", "arm64"]
    },
    {
      "name": "1.87.0-alpine",
      "last_updated": "2026-04-14T07:44:20.000000Z",
      "architectures": ["amd64"]
    }
  ],
  "source": "hub.docker.com"
}
```

---

### Tool: `neonia_dev_architect`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_dev_architect>

#### Description
CRITICAL: Use this tool WHENEVER you need to create a new project or start a major feature. It acts as a strict Senior Software Architect. Pass the exact tech stack and it returns an industry-standard folder tree, essential dependencies, and architectural best practices. Do not guess the project structure—always consult this tool first.

#### Usage Guidelines
Your virtual Senior Software Architect. Before writing any code, this tool provisions an industry-standard folder structure, essential dependencies, and architectural best practices for your specific technology stack (e.g., Next.js, Express, Rust), ensuring your new project starts on a solid foundation.

#### Example Input
```json
{
  "stack": "Next.js, Tailwind, TypeScript"
}
```

#### Example Output
```json
{
  "stack": "nextjs",
  "tree": "src/\n  app/\n...",
  "best_practices": [
    "Use Server Actions..."
  ],
  "configs": {
    "dependencies": ["lucide-react", "..."]
  },
  "agent_prompt": "..."
}
```

---

### Tool: `neonia_dev_tester`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_dev_tester>

#### Description
CRITICAL: Use this tool WHENEVER you finish writing a new feature and need to write tests. It acts as your Senior QA Engineer. Pass the testing framework and feature description. It returns strict testing standards, boilerplate code, and forces the generation of edge-case tests. Do not guess how to write tests—use this tool first.

#### Usage Guidelines
Your virtual Senior QA Engineer. Give it a feature description and a testing framework, and it will return strict testing standards, boilerplate code, and force the generation of comprehensive edge-case tests to ensure your code is robust and production-ready.

#### Example Input
```json
{
  "framework": "jest",
  "feature_description": "User login function"
}
```

#### Example Output
```json
{
  "framework": "vitest",
  "feature_description": "JWT Auth Endpoint",
  "boilerplate": "import { describe, it }...",
  "best_practices": [
    "Always isolate external APIs using vi.mock()"
  ],
  "agent_prompt": "..."
}
```

---

### Tool: `neonia_dev_smart_patcher`
- **Version**: 0.2.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_dev_smart_patcher>

#### Description
CRITICAL: Use this tool WHENEVER you need to modify an existing code file instead of rewriting the entire file from scratch. Pass the exact snippet to be replaced in `search_block`, and the updated snippet in `replace_block`. Rule 1: Always include 1-2 lines of unchanged code before and after your target lines in the `search_block` to ensure uniqueness. Rule 2: Preserve original indentation. Smart Match handles indentation mismatches (tabs vs spaces, varying indent width) automatically. NOTE: provide EITHER original_content (pass the file content inline for small files) OR resource_uri (use a neonia://resource/... URI from a previous tool for large files). Local file paths will NOT work.

#### Usage Guidelines
A precision code-editing utility. Instead of rewriting entire files from scratch, this tool applies exact search-and-replace blocks to existing code, preserving indentation and minimizing token output. Smart Match handles whitespace differences gracefully. Supports internal resource URIs for massive datasets.

#### Example Input
```json
  {
    "original_content": "function add(a, b) {\n  return a + b;\n}",
    "search_block": "return a + b;",
    "replace_block": "return a + b + 0;"
  }


  {
    "resource_uri": "neonia://resource/uuid",
    "search_block": "return a + b;",
    "replace_block": "return a + b + 0;"
  }
```

#### Example Output
```json
{
  "status": "success",
  "patched_content": "fn main() { ... }",
  "message": "Patched successfully via Exact Match. Output tokens saved: ~250"
}
```

---

### Tool: `neonia_dev_mock_data_generator`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_dev_mock_data_generator>

#### Description
CRITICAL: Use this tool WHENEVER you need to generate realistic mock data (names, emails, addresses, text, avatars, or custom JSON schemas) for UI testing, database seeding, or API mocking. DO NOT manually hallucinate mock data.

#### Usage Guidelines
A dynamic fake data generator. It safely and instantly creates large arrays of high-quality mock data natively—from names and addresses to random numbers and complex JSON schemas—eliminating the need for custom Python/Bash scripts when seeding databases or UI components.

#### Example Input
```json
{
  "entity_type": "custom",
  "count": 3,
  "schema": {
    "user_id": "uuid",
    "full_name": "name",
    "email_address": "email"
  }
}
```

#### Example Output
```json
[
  {
    "id": "c4d12c82-...",
    "name": "John Doe",
    "avatar_url": "https://i.pravatar.cc/150?u=123"
  }
]
```

---

### 🌐 Web & Knowledge

### Tool: `neonia_web_url_to_markdown`
- **Version**: v0.3.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_web_url_to_markdown>

#### Description
CRITICAL: Use this tool WHENEVER you need to read the contents of a specific URL. It extracts the core content in a clean 'Reader View' Markdown format, stripping ads and navigation. ALWAYS use this after a web search if you need to read the full article or documentation.

#### Usage Guidelines
A powerful web scraping utility that fetches the contents of any web page and converts it into clean, readable Markdown. It acts like a 'Reader View', stripping away ads, navigation menus, and visual clutter so you can focus strictly on the core content and documentation.

#### Example Input
```json
{
  "url": "https://example.com/docs"
}
```

#### Example Output
```json
{
  "title": "Rust Programming Language",
  "markdown_content": "# Rust\n\nA language empowering everyone...\n\n## Getting Started\n\nInstall Rust with curl...",
  "word_count": 1342,
  "source_url": "https://www.rust-lang.org"
}
```

---

### Tool: `neonia_web_topic_researcher`
- **Version**: v0.1.0
- **Tier**: AI Powered Tier
- **Price**: $0.015 / call
- **URL**: <https://neonia.io/tools/neo_web_topic_researcher>

#### Description
CRITICAL: Use this tool WHENEVER you need real-time data, current events, or internet context that falls outside your training data. Returns top articles, news, and snippets. Use this to gather live references from the internet BEFORE writing articles, documentation, or answering factual questions.

#### Usage Guidelines
A live internet research assistant. It searches the web in real-time to return the top articles, news, and snippets on any given topic. Perfect for gathering current events, trends, or references that fall outside of historical training data.

#### Example Input
```json
{
  "query": "Latest breakthroughs in quantum computing"
}
```

#### Example Output
```json
{
  "topic": "rust webassembly",
  "sources": [
    {
      "title": "Rust and WebAssembly",
      "snippet": "Rust and WebAssembly Book...",
      "url": "https://rustwasm.github.io/"
    }
  ]
}
```

---

### Tool: `neonia_web_wiki_search`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_web_wiki_search>

#### Description
CRITICAL: Use this tool WHENEVER you need foundational encyclopedic knowledge, definitions, historical dates, or established facts. Searches Wikipedia and returns the top articles and snippets.

#### Usage Guidelines
An encyclopedic knowledge retrieval tool. It searches Wikipedia to provide the top articles, definitions, and snippets for any specific topic, giving you instant access to established facts and historical dates.

#### Example Input
```json
{
  "query": "Quantum mechanics"
}
```

#### Example Output
```json
{
  "topic": "rust webassembly",
  "sources": [
    {
      "title": "WebAssembly",
      "snippet": "WebAssembly (often shortened to Wasm)...",
      "url": "https://en.wikipedia.org/wiki/WebAssembly"
    }
  ]
}
```

---

### Tool: `neonia_web_plagiarism_checker`
- **Version**: 0.1.0
- **Tier**: Ultra Tier
- **Price**: $0.055 / call
- **URL**: <https://neonia.io/tools/neo_web_plagiarism_checker>

#### Description
CRITICAL: Use this tool WHENEVER the user asks you to verify the originality of text, check for plagiarism, or ensure content is not duplicated from the web. STRICT CONSTRAINTS: The input text MUST be between 15 and 300 words. If the user provides a text longer than 300 words, you MUST extract and send only the most representative 300-word chunk.

#### Usage Guidelines
A professional originality verification tool. It uses the Copyscape API to check if a provided text snippet appears elsewhere on the internet, ensuring your content is unique and not duplicated from external sources.

#### Example Input
```json
{
  "text": "The quick brown fox jumps over the lazy dog..."
}
```

#### Example Output
```json
{
  "plagiarism_percentage": 12.0,
  "plagiarized_urls": ["https://example.com"]
}
```

---

### Tool: `neonia_web_json_fetch`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_web_json_fetch>

#### Description
CRITICAL: Use this tool WHENEVER you need to read JSON data from a URL. It stores the data as a neonia:// resource and automatically infers a TypeScript type schema for the data.

#### Usage Guidelines
A specialized networking and type inference tool designed for AI agents handling large datasets. Instead of returning massive raw JSON strings that consume valuable context tokens, this tool fetches the remote JSON file, securely stores it as an internal neonia:// resource, and intelligently generates a strict TypeScript type definition based on the data's structure. This guarantees type safety and significantly optimizes context window usage, allowing agents to seamlessly process and query complex APIs.

#### Example Input
```json
{
  "url": "https://api.example.com/data.json"
}
```

#### Example Output
```json
{
  "resource_uri": "neonia://resources/123",
  "ts_schema": "type JsonData = {\n  id: number;\n};"
}
```

---

### ⚙️ Utilities, Data & Vision

### Tool: `neonia_util_rng`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_rng>

#### Description
CRITICAL: Use this tool WHENEVER you need random numbers, strings, or data distributions. Do NOT hallucinate random data. Use this utility to guarantee exact statistical randomness or deterministic seeded RNG for Monte Carlo simulations, UUID generations, or numeric data testing.

#### Usage Guidelines
A robust random number generation tool. Whether you need cryptographically secure random sequences, fast pseudo-random distributions, or deterministic seeded data, this utility guarantees exact statistical randomness for Monte Carlo simulations, UUID generations, or numeric data testing.

#### Example Input
```json
{
  "mode": "integer",
  "min": 1,
  "max": 100
}
```

#### Example Output
```json
{
  "results": [0.523, 0.119, 0.992],
  "metadata": {
    "engine": "secure",
    "executed_in_ms": 1.25
  }
}
```

---

### Tool: `neonia_util_id_generator`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_id_generator>

#### Description
CRITICAL: Use this tool WHENEVER you need to generate UUIDs, database IDs, or mock data. Do NOT hallucinate identifiers. Overcomes LLM hallucination of identifiers.

#### Usage Guidelines
A secure identifier generation utility. It reliably creates UUIDs (v4, v7), random strings, and random numbers without the risk of AI hallucination, making it perfect for database seeding and mock data creation.

#### Example Input
```json
{
  "type": "uuidv4"
}
```

#### Example Output
```json
["018fefb0-4f30-7603-a120-7f2f1837a4c7", "018fefb0-4f31-7bc9-9230-8a4b6c3e98b0"]
```

---

### Tool: `neonia_util_datetime`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_datetime>

#### Description
CRITICAL: Use this tool WHENEVER you need to perform date manipulations or timezone conversions. Do NOT hallucinate calculations. This guarantees exact calendar math.

#### Usage Guidelines
A precision calendar and time manipulation utility. It performs exact date arithmetic and timezone conversions, eliminating calculation errors and hallucination risks when working with timestamps across global regions.

#### Example Input
```json
{
  "action": "now",
  "timezone": "UTC"
}
```

#### Example Output
```json
{
  "iso8601": "2026-04-17T09:00:00+09:00",
  "human_readable": "2026-04-17 09:00:00 JST"
}
```

---

### Tool: `neonia_util_crypto_encoder`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_crypto_encoder>

#### Description
CRITICAL: Use this tool WHENEVER you need to hash strings (SHA256, MD5) or perform Base64 encoding/decoding. Do NOT hallucinate hashes. This guarantees exact cryptographic operations.

#### Usage Guidelines
A cryptographic utility for exact hashing (SHA256, MD5) and Base64 encoding/decoding operations. It ensures mathematical precision for security-sensitive transformations.

#### Example Input
```json
{
  "action": "hash",
  "algorithm": "sha256",
  "data": "secret"
}
```

#### Example Output
```json
{
  "result": "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
}
```

---

### Tool: `neonia_util_regex_extractor`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_regex_extractor>

#### Description
CRITICAL: Use this tool WHENEVER you need to extract specific patterns (like emails, UUIDs, or URLs) from massive text blocks. Avoids hallucination skips and saves context tokens. Use `text` to pass content inline, or `resource_uri` to reference a neonia://resource/... URI from a previous tool. Local file paths will NOT work.

#### Usage Guidelines
A powerful data extraction tool. It applies Regular Expressions to quickly and accurately pull structured data (such as emails, IP addresses, and URLs) from massive blocks of text or internal resource URIs, avoiding token limits and hallucination skips.

#### Example Input
```json
  {
    "text": "Contact us at info@example.com",
    "pattern": "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}"
  }



  {
    "resource_uri": "neonia://resource/uuid",
    "pattern": "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}"
  }

```

#### Example Output
```json
["test@example.com", "admin@neonia.io"]
```

---

### Tool: `neonia_util_semantic_similarity`
- **Version**: 0.1.0
- **Tier**: Advanced Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_semantic_similarity>

#### Description
CRITICAL: Use this tool WHENEVER you need to compare two strings to determine their semantic similarity. It returns a score between -1.0 (completely opposite) and 1.0 (identical meaning). Use this for deduplication, zero-shot classification, or finding the most relevant paragraph in a large text without guessing. Provide text inline (text_1/text_2) for small content, or resource URIs (resource_uri_1/resource_uri_2) to reference neonia://resource/... URIs from previous tools. Local file paths will NOT work.

#### Usage Guidelines
An advanced NLP utility that compares two strings (or internal resource URIs) to determine their semantic similarity. It calculates a score between -1.0 (completely opposite) and 1.0 (identical meaning), making it ideal for data deduplication, zero-shot classification, and intent matching.

#### Example Input
```json
  {
    "text_1": "Hello world",
    "text_2": "Hi earth"
  }


  {
    "text_1": "Hello world",
    "resource_uri_2": "neonia://resource/uuid"
  }

```

#### Example Output
```json
{
  "similarity_score": 0.852
}
```

---

### Tool: `neonia_util_ai_text_detector`
- **Version**: 0.1.0
- **Tier**: Ultra Tier
- **Price**: $0.055 / call
- **URL**: <https://neonia.io/tools/neo_util_ai_text_detector>

#### Description
CRITICAL: Use this tool WHENEVER you need to verify human authorship or check for AI footprints. Evaluates text to determine the probability that it was generated by an AI model. STRICT CONSTRAINT: The input text MUST contain at least 30 words and no more than 300 words, otherwise the upstream API will fail.

#### Usage Guidelines
An AI footprint detection tool. It analyzes the linguistic patterns of a text to determine the probability that it was generated by an AI model, helping you verify human authorship.

#### Example Input
```json
{
  "text": "As an AI language model, I can assist you..."
}
```

#### Example Output
```json
{
  "ai_generation_probability": 0.98
}
```

---

### Tool: `neonia_vision_image_to_json`
- **Version**: v1.0.0
- **Tier**: Ultra Tier
- **Price**: $0.055 / call
- **URL**: <https://neonia.io/tools/neo_vision_image_to_json>

#### Description
CRITICAL: Use this tool WHENEVER you need to analyze, read, or extract data from an image file (e.g. screenshots, diagrams, photos). Extracts structured JSON information from an image using a Vision LLM (Qwen3-VL) and a provided JSON schema. NOTE: provide EITHER image_base64 (for direct analysis — pass the raw base64-encoded image) OR resource_uri (for images generated by other tools — pass their neonia://resource/... output URI). Local file paths will NOT work — use image_base64 instead.

#### Usage Guidelines
An advanced multimodal extraction tool. It uses Vision LLM capabilities (Qwen3-VL) to analyze images, screenshots, and diagrams, extracting the visual data and mapping it directly into a structured JSON schema you provide.

#### Example Input
```json
{
  "image_base64": "/9j/4AAQSkZJRgABAQAAAQABAAD...",
  "prompt": "Analyze this image and extract the cat details.",
  "schema": {
    "type": "object",
    "properties": {
      "has_cat": { "type": "boolean", "description": "Is there a cat in the image?" },
      "cat_color": { "type": "string", "description": "The color of the cat, if present." }
    },
    "required": ["has_cat", "cat_color"],
    "additionalProperties": false
  }
}
```

#### Example Output
```json
{
  "has_cat": true,
  "cat_color": "orange"
}
```

---

### Tool: `neonia_data_jq_filter`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_data_jq_filter>

#### Description
CRITICAL: Use this tool WHENEVER you need to process large JSON datasets using jq syntax without overwhelming your context window. NOTE: provide EXACTLY ONE data source — raw_json (pass JSON inline for small payloads), data_url (fetch directly from a URL), or resource_uri (use a neonia://resource/... URI from a previous tool's output for chain workflows). Local file paths will NOT work.

#### Usage Guidelines
A powerful data processing tool that securely executes JQ filters on JSON datasets, supporting large files via external URL or internal resource_uri. Essential for API integration and data transformation tasks.

#### Example Input
```json
  {
    "raw_json": "{\"users\":[{\"role\":\"admin\",\"email\":\"a@x.com\"}]}",
    "jq_query": ".users[] | select(.role == \"admin\") | .email"
  }


  {
    "resource_uri": "neonia://resource/uuid",
    "jq_query": ".users[] | select(.role == \"admin\") | .email"
  }

```

#### Example Output
```json
["admin@example.com", "user@example.com"]
```

---

### Tool: `neonia_util_svg_validator`
- **Version**: 2.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_svg_validator>

#### Description
COMPUTE-ONLY: A strict geometric linter for SVG code. Provide singular svg_content/svg_resource_uri inputs for one SVG, or plural svg_contents/svg_resource_uris arrays for batches. Local file paths will NOT work.

#### Usage Guidelines
A geometric linter for SVG graphics designed for physical manufacturing.

#### Example Input
```json
{
  "svg_contents": ["<svg xmlns=...></svg>"]
}
```

#### Example Output
```json
{
  "is_valid": false,
  "errors": [
    "[Item 0] Path 'path_0' is not closed (missing Z command)."
  ],
  "warnings": []
}
```

---

### Tool: `neonia_util_svg_layout_validator`
- **Version**: 1.0.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_svg_layout_validator>

#### Description
COMPUTE-ONLY: A spatial layout placement validator for SVG workflows. Use this tool when arranging multiple vector components on a canvas. It detects spatial bounding-box collisions between components to ensure proper physical assembly or layout rendering.

#### Usage Guidelines
A spatial layout placement validator for checking component bounding box collisions on a 2D canvas.

#### Example Input
```json
{
  "components": [
    { "component_id": "c1", "x": 10, "y": 10, "width": 50, "height": 50, "allow_overlap": false },
    { "component_id": "c2", "x": 30, "y": 30, "width": 20, "height": 20, "allow_overlap": false }
  ]
}
```

#### Example Output
```json
{
  "is_valid": false,
  "errors": [
    "Spatial collision detected between 'c1' and 'c2'."
  ],
  "warnings": []
}
```

---

### Tool: `neonia_util_svg_generator`
- **Version**: 1.0.0
- **Tier**: Ultra Tools
- **Price**: $0.055 / call
- **URL**: <https://neonia.io/tools/neo_util_svg_generator>

#### Description
Generates scalable SVG vector graphics based on a text prompt. The system handles raster image generation automatically and mathematically vectorizes the result using vtracer. Uses a pass-by-reference architecture where the raw SVG is written to the Wasm filesystem and only the file URI is returned.

#### Usage Guidelines
A Universal SVG Generator that acts as a Multi-Modal Raster-to-Vector pipeline. It generates an image using a diffusion model based on a style preset, and then mathematically traces it into an optimized, geometrically perfect SVG vector file.

#### Example Input
```json
{
  "prompt": "A mechanical gear with 12 teeth",
  "style_preset": "laser_cut"
}
```

#### Example Output
```json
{
  "status": "success",
  "svg_resource_uri": "neonia://resource/uuid"
}
```

---

### Tool: `neonia_util_pathfinder`
- **Version**: v0.1.0
- **Tier**: Standard Tier
- **Price**: $0.002 / call
- **URL**: <https://neonia.io/tools/neo_util_pathfinder>

#### Description
COMPUTE-ONLY: Use this tool to calculate a visual routing path (polyline) between two coordinates on a 2D canvas, avoiding existing rectangular buildings. Returns a sequence of points forming a collision-free path.

#### Usage Guidelines
A 2D A* pathfinding utility. Calculates orthogonal routes between points while avoiding defined rectangular obstacles.

#### Example Input
```json
{
  "start": {"x": 0, "y": 0},
  "end": {"x": 100, "y": 100},
  "obstacles": [
    {"id": "b1", "x": 20, "y": 20, "width": 50, "height": 50}
  ],
  "padding": 15
}
```

#### Example Output
```json
{
  "status": "success",
  "path": [
    {"x": 100, "y": 150},
    {"x": 100, "y": 250},
    {"x": 300, "y": 250},
    {"x": 300, "y": 180}
  ],
  "svg_polyline": "100,150 100,250 300,250 300,180"
}
```

---