Rozmawiaj z Joshuą
ze swoich programów

Na początek

1. Otwórz Joshuę. API startuje razem z nim, pod adresem http://127.0.0.1:7861/v1.
2. W prawej kolumnie otwórz 🔌 API. Pokazuje adres, twój klucz i gotowe polecenie do wypróbowania.
3. Skopiuj klucz. Każde zapytanie musi go mieć, jak hasło. Zna go tylko twój komputer; Utwórz nowy klucz zastępuje go, gdyby kiedyś wyciekł.

Joshua musi działać, żeby API odpowiadało. Klucz jest zapisany w ~/AskJoshua/joshua/api.json.

Twoje pierwsze zapytanie

W Terminalu wypisz modele, których możesz użyć, a potem zadaj pytanie. Zastąp YOUR-KEY kluczem z panelu.

curl http://127.0.0.1:7861/v1/models \
  -H "Authorization: Bearer YOUR-KEY"

curl http://127.0.0.1:7861/v1/chat/completions \
  -H "Authorization: Bearer YOUR-KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "joshua",
    "messages": [{"role": "user", "content": "What is the weather in Turin today?"}]
  }'

Odpowiedź wraca w standardowym formacie; tekst jest w choices[0].message.content:

{
  "id": "chatcmpl-5f2c9a01",
  "object": "chat.completion",
  "model": "qwen3-vl:8b-instruct",
  "choices": [{
    "index": 0,
    "message": {"role": "assistant", "content": "Oggi è domenica, 8 novembre 2026."},
    "finish_reason": "stop"
  }]
}

Joshua może przed odpowiedzią szukać w sieci, czytać strony albo uruchamiać kod, więc odpowiedź może trwać od kilku sekund do kilku minut, zależnie od pytania i komputera.

Python

Najprościej użyć oficjalnej biblioteki openai: skieruj ją na Joshuę zamiast na OpenAI.

# pip install openai
from openai import OpenAI

joshua = OpenAI(base_url="http://127.0.0.1:7861/v1", api_key="YOUR-KEY")

reply = joshua.chat.completions.create(
    model="joshua",
    messages=[{"role": "user", "content": "Summarise today's main news in Italy in three lines."}],
)
print(reply.choices[0].message.content)

Albo prostym requests, na przykład na robocie z Raspberry Pi, który prowadzi rozmowę, za każdym razem odsyłając historię:

# pip install requests
import requests

URL = "http://192.168.1.20:7861/v1/chat/completions"   # your computer's address on the home network
KEY = "YOUR-KEY"

def ask_joshua(text, history=()):
    messages = [*history, {"role": "user", "content": text}]
    r = requests.post(URL, headers={"Authorization": f"Bearer {KEY}"},
                      json={"model": "joshua", "messages": messages}, timeout=600)
    r.raise_for_status()
    return r.json()["choices"][0]["message"]["content"]

print(ask_joshua("Which washing programme for a shirt marked 40 °C, gentle?"))

JavaScript

const reply = await fetch("http://127.0.0.1:7861/v1/chat/completions", {
  method: "POST",
  headers: { "Authorization": "Bearer YOUR-KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "joshua",
    messages: [{ role: "user", content: "Write a haiku about Turin in the fog." }],
  }),
}).then(r => r.json());

console.log(reply.choices[0].message.content);

Strona internetowa z innej witryny nie może wywołać Joshui bezpośrednio; uruchom to w Node albo w swojej aplikacji.

Wysyłanie obrazów

Wyślij zdjęcie jako adres data: w wiadomości. Z modelem, który widzi obrazy (qwen3-vl widzi), Joshua patrzy na nie bezpośrednio; w przeciwnym razie używa swojego lokalnego narzędzia do obrazów.

import base64
from openai import OpenAI

joshua = OpenAI(base_url="http://127.0.0.1:7861/v1", api_key="YOUR-KEY")
photo = base64.b64encode(open("label.jpg", "rb").read()).decode()

reply = joshua.chat.completions.create(model="joshua", messages=[{
    "role": "user",
    "content": [
        {"type": "text", "text": "What does this care label say?"},
        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{photo}"}},
    ],
}])
print(reply.choices[0].message.content)

Opcje

Możesz dać Joshui dodatkowe instrukcje wiadomością system: są dodawane po jego własnych. Możesz też poprosić, żeby nie zapisywał wymiany jako rozmowy:

reply = joshua.chat.completions.create(
    model="joshua",
    messages=[
        {"role": "system", "content": "You are the voice of a small robot. Answer in one short sentence, in Italian."},
        {"role": "user", "content": "Che ore sono?"},
    ],
    extra_body={"joshua_save": False},   # don't keep this exchange as a chat
)

Z innych urządzeń

Domyślnie połączyć się mogą tylko programy na tym samym komputerze. Żeby używać Joshui z robota, telefonu albo innego komputera w domu:

1. W 🔌 API zaznacz Zezwalaj innym urządzeniom w mojej sieci.
2. Uruchom Joshuę ponownie (uruchom ~/AskJoshua/stop.sh, a potem otwórz Joshuę jeszcze raz).
3. Panel pokazuje teraz adres sieciowy twojego komputera, np. http://192.168.1.20:7861/v1. Użyj tego adresu na drugim urządzeniu, z tym samym kluczem.

Trzymaj to w sieci domowej. Nie otwieraj portu 7861 na routerze: klucz chroni Joshuę, ale połączenie nie jest szyfrowane.

Dokumentacja

Potrzebujesz tylko samego modelu, bez narzędzi i pamięci Joshui? Ollama ma własne API pod http://127.0.0.1:11434, zgodne z OpenAI także pod /v1, bez klucza.

Prywatność

• Z modelem lokalnym zapytania dostają odpowiedź w całości na twoim komputerze.
• Każde zapytanie jest zapisywane w Joshui jako rozmowa 🔌, więc zawsze widzisz, o co pytały programy, chyba że program wyśle joshua_save: false.
• Zapytania API nie są dodawane do pamięci, którą Joshua ma o tobie, ale modele lokalne mogą używać twoich notatek do odpowiedzi.
• Model w chmurze jest używany tylko, gdy program poprosi o niego z nazwy; wtedy rozmowa trafia na serwery Ollamy, jak opisano w gdzie są twoje dane.