Sovereign Multi-Modal AI on Old Phone Hardware

Copyconst BASE_URL = "https://phone-whisper-server.pages.dev";

// 1. Token-by-Token Streaming Chat (Qwen 2.5 SLM)
export async function streamChat(prompt, onToken, systemPrompt = "You are a helpful AI.") {
  const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: prompt }
      ],
      stream: true
    })
  });

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    const chunk = decoder.decode(value);
    for (const line of chunk.split("\n")) {
      if (line.startsWith("data: ") && !line.includes("[DONE]")) {
        const delta = JSON.parse(line.slice(6))?.choices?.[0]?.delta?.content;
        if (delta) onToken(delta);
      }
    }
  }
}

// 2. Audio Transcription (Whisper STT)
export async function transcribeAudio(audioBlob) {
  const formData = new FormData();
  formData.append("file", audioBlob, "audio.wav");
  const res = await fetch(`${BASE_URL}/inference`, { method: "POST", body: formData });
  return await res.json();
}

// 3. Text-to-Speech (Piper VITS TTS)
export async function playTextToSpeech(text) {
  const res = await fetch(`${BASE_URL}/v1/audio/speech`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ input: text })
  });
  const audioBlob = await res.blob();
  const audioUrl = URL.createObjectURL(audioBlob);
  const audio = new Audio(audioUrl);
  audio.play();
}

// 4. Dense Vector Embeddings
export async function getEmbedding(text) {
  const res = await fetch(`${BASE_URL}/v1/embeddings`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ input: text })
  });
  const json = await res.json();
  return json.data[0].embedding; // 896-dimension array
}

// 5. Deep Cross-Attention Reranker
export async function rerankDocs(query, documents) {
  const res = await fetch(`${BASE_URL}/v1/rerank`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ query, documents })
  });
  return await res.json();
}

// 6. MediaPipe Vision (Image / Video Sequence / Live WebCam Frame)
export async function detectVision(imageBlobOrBase64, task = "face_detection", isLiveStream = false) {
  let b64 = imageBlobOrBase64;
  if (imageBlobOrBase64 instanceof Blob) {
    b64 = await new Promise(r => {
      const reader = new FileReader();
      reader.onload = () => r(reader.result);
      reader.readAsDataURL(imageBlobOrBase64);
    });
  }
  const res = await fetch(`${BASE_URL}/v1/vision/${task.replace(/_/g, "-")}`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ task, image_base64: b64, is_live_stream: isLiveStream })
  });
  return await res.json();
}

// 7. Live Kernel Telemetry
export async function getTelemetry() {
  return await fetch(`${BASE_URL}/telemetry`).then(r => r.json());
}

Copy# 1. Chat Completion (SSE Real-Time Stream)
curl -N -X POST "https://phone-whisper-server.pages.dev/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Explain relativity in 10 words"}], "stream": true}'

# 2. Audio Transcription (Whisper Base.en)
curl -X POST "https://phone-whisper-server.pages.dev/inference" \
  -F "file=@audio.wav" \
  -F "temperature=0.0"

# 3. Text-to-Speech (Neural Voice Synthesis)
curl -X POST "https://phone-whisper-server.pages.dev/v1/audio/speech" \
  -H "Content-Type: application/json" \
  -d '{"input": "Hello from autonomous phone AI datacenter"}' \
  --output speech.wav

# 4. Dense Vector Embeddings (896 Dimensions)
curl -X POST "https://phone-whisper-server.pages.dev/v1/embeddings" \
  -H "Content-Type: application/json" \
  -d '{"input": "Semantic vector search on mobile AI"}'

# 5. Deep Cross-Attention Semantic Reranker
curl -X POST "https://phone-whisper-server.pages.dev/v1/rerank" \
  -H "Content-Type: application/json" \
  -d '{"query": "The company approved funding.", "documents": ["The venture received investment.", "The engine is made of steel."]}'

# 6. MediaPipe Vision: Face & Landmark Detection
curl -X POST "https://phone-whisper-server.pages.dev/v1/vision/face-detection" \
  -H "Content-Type: application/json" \
  -d '{"task": "face_detection", "image_base64": "data:image/jpeg;base64,..."}'

# 7. Real Battery & Kernel Telemetry (Real-Time Metrics)
curl -s "https://phone-whisper-server.pages.dev/telemetry" | jq .battery

Copyimport 'dart:convert';
import 'dart:typed_data';
import 'package:http/http.dart' as http;

class PhoneAIClient {
  static const String baseUrl = "https://phone-whisper-server.pages.dev";

  // 1. Qwen 2.5 SLM Chat (Streaming & Full)
  static Future<String> chat(String prompt, {String systemPrompt = "You are a helpful AI assistant."}) async {
    final res = await http.post(
      Uri.parse("$baseUrl/v1/chat/completions"),
      headers: {"Content-Type": "application/json"},
      body: jsonEncode({
        "messages": [
          {"role": "system", "content": systemPrompt},
          {"role": "user", "content": prompt}
        ],
        "stream": false,
        "temperature": 0.7,
        "max_tokens": 256
      }),
    );
    final data = jsonDecode(res.body);
    return data["choices"][0]["message"]["content"];
  }

  // 2. Whisper Audio STT
  static Future<String> transcribe(Uint8List audioBytes) async {
    final req = http.MultipartRequest("POST", Uri.parse("$baseUrl/inference"));
    req.files.add(http.MultipartFile.fromBytes("file", audioBytes, filename: "audio.wav"));
    req.fields["response_format"] = "json";
    req.fields["temperature"] = "0.0";
    final streamRes = await req.send();
    final res = await http.Response.fromStream(streamRes);
    return jsonDecode(res.body)["text"];
  }

  // 3. Piper VITS Neural Text-to-Speech (TTS)
  static Future<Uint8List> textToSpeech(String text) async {
    final res = await http.post(
      Uri.parse("$baseUrl/v1/audio/speech"),
      headers: {"Content-Type": "application/json"},
      body: jsonEncode({"input": text, "speed": 1.0}),
    );
    return res.bodyBytes;
  }

  // 4. Dense Vector Embeddings (896 Dimensions)
  static Future<List<double>> getEmbedding(String text) async {
    final res = await http.post(
      Uri.parse("$baseUrl/v1/embeddings"),
      headers: {"Content-Type": "application/json"},
      body: jsonEncode({"input": text}),
    );
    final data = jsonDecode(res.body);
    return List<double>.from(data["data"][0]["embedding"]);
  }

  // 5. Deep Cross-Attention Semantic Reranker
  static Future<Map<String, dynamic>> rerank(String query, List<String> documents) async {
    final res = await http.post(
      Uri.parse("$baseUrl/v1/rerank"),
      headers: {"Content-Type": "application/json"},
      body: jsonEncode({"query": query, "documents": documents}),
    );
    return jsonDecode(res.body);
  }

  // 6. Google MediaPipe Vision (Image & Video)
  static Future<Map<String, dynamic>> detectVision(String base64Image, {String task = "face_detection"}) async {
    final res = await http.post(
      Uri.parse("$baseUrl/v1/vision/${task.replaceAll('_', '-')}"),
      headers: {"Content-Type": "application/json"},
      body: jsonEncode({"task": task, "image_base64": base64Image}),
    );
    return jsonDecode(res.body);
  }

  // 7. Real-Time Hardware Telemetry
  static Future<Map<String, dynamic>> getTelemetry() async {
    final res = await http.get(Uri.parse("$baseUrl/telemetry"));
    return jsonDecode(res.body);
  }
}

Rust Async Implementation (tokio + reqwest)

Copyuse reqwest::Client;
use serde_json::json;
use futures_util::StreamExt;

const BASE_URL: &str = "https://phone-whisper-server.pages.dev";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // 1. Stream Qwen 2.5 SLM Chat
    println!("[Chat] Asking Qwen SLM...");
    let payload = json!({
        "messages": [{"role": "user", "content": "Explain quantum physics in 15 words"}],
        "stream": true
    });
    let mut stream = client
        .post(format!("{}/v1/chat/completions", BASE_URL))
        .json(&payload)
        .send()
        .await?
        .bytes_stream();

    while let Some(item) = stream.next().await {
        let chunk = item?;
        print!("{}", String::from_utf8_lossy(&chunk));
    }

    // 2. Fetch Hardware Telemetry
    let tel: serde_json::Value = client
        .get(format!("{}/telemetry", BASE_URL))
        .send()
        .await?
        .json()
        .await?;
    println!("\n\n[Battery] Phone Battery: {}%", tel["battery"]["level"]);

    Ok(())
}

Go (Golang) Production Microservice Wrapper

Copypackage main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

const BaseURL = "https://phone-whisper-server.pages.dev"

// 1. StreamChat streams tokens live from phone CPU
func StreamChat(prompt string) error {
	payload, _ := json.Marshal(map[string]interface{}{
		"messages": []map[string]string{{"role": "user", "content": prompt}},
		"stream":   true,
	})
	resp, err := http.Post(BaseURL+"/v1/chat/completions", "application/json", bytes.NewBuffer(payload))
	if err != nil { return err }
	defer resp.Body.Close()

	buf := make([]byte, 1024)
	for {
		n, err := resp.Body.Read(buf)
		if n > 0 { fmt.Print(string(buf[:n])) }
		if err == io.EOF { break }
		if err != nil { return err }
	}
	return nil
}

// 2. GetTelemetry returns real-time kernel hardware stats
func GetTelemetry() (map[string]interface{}, error) {
	resp, err := http.Get(BaseURL + "/telemetry")
	if err != nil { return nil, err }
	defer resp.Body.Close()

	var result map[string]interface{}
	err = json.NewDecoder(resp.Body).Decode(&result)
	return result, err
}

func main() {
	fmt.Println("[Stream] Streaming from On-Device Phone AI:")
	StreamChat("What is edge computing?")
}

Copy# 1. Update and install packages in Termux
pkg update && pkg install -y git clang cmake tmux espeak python nodejs

# 2. Clone repo & build whisper.cpp + llama.cpp with ARM NEON optimizations
git clone --recursive https://github.com/Electroiscoding/phone-whisper-server
cd phone-whisper-server

# 3. Launch 24/7 self-healing supervisor (survives app kills, tunnel rotations & reboots)
python3 mobile/nuclear_watchdog.py