Nervo API Instructions

1. What is Nervo API?

Nervo API is the nerve between your world and the UCO Core. You send messages, tasks and events to Nervo, the core decides what to do, and Nervo calls the right AI fabrics on your behalf.

You don’t talk to OpenAI / xAI / Kling directly. You talk to /nevro/chat — the brain does the rest.

Key idea: you own the fabrics (API keys, models, providers), UCO owns the brain (core, orchestration, logic). Nervo connects them.

2. Two modes of using Nervo

2.1. Fast start: default fabric

For quick tests and demos you can use the default fabric stack configured on UCO side. No setup, just an API key from us.

Get your Nervo API key from the UCO dashboard.
Call /nevro/chat with "fabric_profile": "default".

2.2. Full power: Bring Your Own Fabric (BYOF)

In production you can connect your own AI providers: OpenAI, xAI, DeepSeek, local models, Kling (video), TTS and more.

You describe them once in a fabric_profile, and then reuse that profile from any chat or task.

Store your provider keys on your side or via Nervo secure config.
Create a fabric_profile via API.
Use that profile name for all future calls.

3. Minimal integration flow

Register & get Nervo API key.
Use it as Authorization: Bearer <key>.
Optionally create a fabric profile.
Connect your OpenAI/xAI/DeepSeek/Kling/etc via /nevro/fabric-profiles.
Call /nevro/chat from your product.
Web chat, Telegram bot, your backend, CRM — anything that can send HTTP.
Handle the response.
Show it in chat, turn it into content, trigger actions, etc.

4. Conceptual architecture

At a high level, Nervo sits in the middle:

              Client / Product (chat, bot, site, app) │ ▼ Nervo API
              (/nevro/chat, /nevro/fabric-profiles) │ ▼ UCO Core (fractal brain
              & orchestration) │ ▼ Fabric Adapters (OpenAI, xAI, DeepSeek,
              Kling, TTS, local models)
            

You never have to call AI providers directly from your front-end. All traffic goes through Nervo → Core → fabrics.

/nevro/chat

POST chat endpoint

Send a message/event to the core. The core decides what to do and how to use the fabrics.

POST https://uco.hacs.world/api/nevro/chat

              { "session_id": "user-123", "text": "Create a post for my X
              account about UCO.", "channel": "g-chat", "fabric_profile":
              "default" }
            

session_id groups messages into one logical conversation.
fabric_profile defines which providers to use ("default" or your own).

Example response

              { "session_id": "user-123", "core_trace_id": "core-9f7b1c",
              "reply": "Here is a suggested X post about UCO...", "actions": [],
              "meta": { "intent": "creative", "contour": "outer",
              "provider_route": ["openai:gpt-4.1"] } }
            

/nevro/fabric-profiles

POST configure fabrics

Create or update a fabric_profile that tells the core which AI providers to use for this client.

POST https://uco.hacs.world/api/nevro/fabric-profiles

              { "profile_id": "my-openai-stack", "llm": { "provider": "openai",
              "base_url": "https://api.openai.com/v1", "api_key": "sk-***",
              "model": "gpt-4.1" }, "image": { "provider": "kling", "api_key":
              "kl-***" }, "tts": { "provider": "my-tts", "api_key": "tts-***" }
              }
            

In production you can store API keys encrypted on server-side or use a secrets manager. The important part: profile_id is what you pass as fabric_profile to /nevro/chat.

Auth & headers

basics

All Nervo API calls follow the same pattern:

              POST /api/nevro/... Authorization: Bearer
              <your_nervo_api_key> Content-Type: application/json
            

Your Nervo API key is issued in the UCO dashboard. Keep it secret and do not expose it in front-end code.

HTTPS only JSON payloads Bearer auth

Typical use cases

what you can run through Nervo

One chat on your site that controls all your AI features.
Social media autopilot (content + video + voice-over) via one brain.
Internal assistant that sees your stack as one system, not many tools.
Agents that act across platforms using your fabrics.

If it can be expressed as messages + actions, it can run through Nervo.