Purpose-built delivery

Request. Receive. Run. Integrate.

A TWiN Compass derivative provided for your use case can run entirely as a local Ollama model, with no cloud service required. Intranet and cloud hosting remain optional for organizations that choose them.

A purchased commercial license is a one-time purchase for the licensed version, with no monthly subscription or mandatory recurring TWiN Compass license fee after purchase. Optional hosting, customization, support, upgrades, and third-party services may cost extra.

Request A Derivative Integration Examples

Run your derivative with Ollama

Receive a model tailored to your use case, then run it.

Request Your Derivative

The Wizard Nexus will provide the derivative and its model name after reviewing your intended users, workflow, deployment environment, and safety requirements.

ollama run your-provided-derivative

C-level leaders can evaluate it quickly. Architects and engineers can connect it to existing systems. Mental health professionals can use implementations that fit Health Insurance Portability and Accountability Act (HIPAA)-aware environments with personally identifiable information (PII) controls, audit trails, and existing clinical responsibility unchanged.

Deployment choices

Choose the environment that matches the risk.

Local Machine

Best for strict data privacy, no-network data handling, cyber-secure environments, offline use, field work, research, regulated data review, and online or offline systems where sensitive information should stay on one workstation.

Local Intranet

Best for teams that want internal access, network controls, identity management, Electronic Health Record (EHR)-adjacent integration, logging, local governance, and institutional review board (IRB)-friendly pilots.

Cloud

Best for scalable products, distributed teams, client portals, support centers, analysis workloads, and managed deployments with appropriate business associate agreements (BAAs), controls, and monitoring.

Deployment planning can account for HIPAA, PII, access control, auditability, retention, consent, IRB review, and human oversight when those requirements apply.

Prompt directions

Designed for moral, ethical, cultural, and behavioral-health workflows.

Ethical decision review: Map this proposed workflow for affected people, possible benefits, risks, cultural concerns, consent needs, and safer alternatives.
Leadership brief: Prepare a moral and ethical context brief for a high-stakes decision involving staff, clients, public trust, and reputation risk.
Education and culture fit: Rewrite this message for a user with this language, education level, stress state, and cultural context while keeping it respectful and clear.
Biopsychosocial context: Summarize this intake note into biological, psychological, social, risk, strengths, and follow-up themes.
Care record continuity: Review these Electronic Health Record (EHR) notes and highlight what I should be aware of for the next session.
Client-facing between sessions: What might help client X reflect on mood, coping, safety, homework, and goals between appointments?
Clinical diagnosis support: Organize observations, differential questions, rule-outs, and care-team discussion points.
Safety planning: Create a personalized Stanley-Brown-style safety plan draft with warning signs, coping steps, social supports, professional contacts, and means-safety reminders.
Goal setting: Turn this session summary into Specific, Measurable, Achievable, Relevant, and Time-bound (SMART) goals, barriers, supports, and next-session check-ins.
Customer support or intake: Triage a conversation for urgency, emotional tone, consent needs, escalation paths, and next best response.
Connected care homework: In a system connected by engineers to the care workflow, support therapy homework, Cognitive Behavioral Therapy (CBT) or Dialectical Behavior Therapy (DBT) skills practice, grounding, journaling, sleep routines, or other care-team-approved exercises.

Application Programming Interface (API)

Integrate your provided derivative into existing products and workflows.

Replace your-provided-derivative with the exact model name supplied by The Wizard Nexus.

Curl

curl http://localhost:11434/api/chat \
  -H "Content-Type: application/json" \
  -d '{
    "model": "your-provided-derivative",
    "messages": [
      {"role": "user", "content": "Summarize this intake note into biopsychosocial themes and safety follow-up questions."}
    ],
    "stream": false
  }'

Python

import requests

payload = {
    "model": "your-provided-derivative",
    "messages": [
        {"role": "user", "content": "Draft a personalized safety planning prompt for a client portal."}
    ],
    "stream": False,
}

response = requests.post("http://localhost:11434/api/chat", json=payload, timeout=60)
print(response.json()["message"]["content"])

Node.js / TypeScript

const response = await fetch("http://localhost:11434/api/chat", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "your-provided-derivative",
    messages: [
      { role: "user", content: "Review this support transcript for escalation and empathy gaps." }
    ],
    stream: false
  })
});

const data = await response.json();
console.log(data.message.content);

Rust

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let payload = json!({
        "model": "your-provided-derivative",
        "messages": [
            {"role": "user", "content": "Create a clinician handoff summary with risks, strengths, and next steps."}
        ],
        "stream": false
    });

    let body = Client::new()
        .post("http://localhost:11434/api/chat")
        .json(&payload)
        .send()
        .await?
        .text()
        .await?;

    println!("{}", body);
    Ok(())
}

Java

HttpClient client = HttpClient.newHttpClient();
String body = """
{
  "model": "your-provided-derivative",
  "messages": [
    {"role": "user", "content": "Review this policy for moral, ethical, cultural, and operational risk."}
  ],
  "stream": false
}
""";

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:11434/api/chat"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

System.out.println(client.send(request, HttpResponse.BodyHandlers.ofString()).body());

Kotlin

val body = """
{
  "model": "your-provided-derivative",
  "messages": [
    {"role": "user", "content": "Create a culturally aware support response."}
  ],
  "stream": false
}
""".trimIndent()

val request = HttpRequest.newBuilder()
  .uri(URI.create("http://localhost:11434/api/chat"))
  .header("Content-Type", "application/json")
  .POST(HttpRequest.BodyPublishers.ofString(body))
  .build()

println(HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString()).body())

C#

using System.Net.Http.Json;

var client = new HttpClient();
var payload = new {
    model = "your-provided-derivative",
    messages = new[] {
        new { role = "user", content = "Prepare a culturally humble intake follow-up." }
    },
    stream = false
};

var response = await client.PostAsJsonAsync("http://localhost:11434/api/chat", payload);
Console.WriteLine(await response.Content.ReadAsStringAsync());

Flutter

final response = await http.post(
  Uri.parse('http://localhost:11434/api/chat'),
  headers: {'Content-Type': 'application/json'},
  body: jsonEncode({
    'model': 'your-provided-derivative',
    'messages': [
      {'role': 'user', 'content': 'Draft a values-aware client check-in.'}
    ],
    'stream': false,
  }),
);

print(jsonDecode(response.body)['message']['content']);

React Native

const response = await fetch("http://localhost:11434/api/chat", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "your-provided-derivative",
    messages: [{ role: "user", content: "Review this intake response for clarity and care." }],
    stream: false
  })
});

const data = await response.json();

Electron

const result = await fetch("http://localhost:11434/api/chat", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "your-provided-derivative",
    messages: [{ role: "user", content: "Prepare an ethics brief for this leadership decision." }],
    stream: false
  })
}).then(r => r.json());

The same pattern can sit behind a desktop app, client portal, clinician dashboard, texting workflow, intake system, support desk, school tool, leadership dashboard, intranet tool, cloud service, or analysis pipeline.