Conecte qualquer app
ao GPU alugado.

Crie um script Python simples que use a biblioteca OpenAI SDK
para abrir um chatbot no terminal. O chatbot deve enviar mensagens
para o endpoint http://127.0.0.1:22434/v1/chat/completions, modelo
"llama3.2". O endpoint é OpenAI-compatible. Use api_key="haon-tunnel"
(qualquer string serve, não é validado). Mantenha o histórico da
conversa entre as mensagens.

Crie um app Flask em Python com uma página HTML simples que tenha
uma caixinha de chat. Quando o usuário envia uma mensagem, o backend
deve chamar http://127.0.0.1:22434/v1/chat/completions (modelo
"llama3.2", endpoint OpenAI-compatible, api_key="haon-tunnel") e
retornar a resposta. Mostra o histórico da conversa na página.
Quero rodar com python app.py.

Crie um script Python que conecte no ComfyUI rodando em
http://127.0.0.1:22434, envie o prompt "uma raposa de origami
laranja em fundo preto, 4k, cinematic" e baixe a imagem gerada
no arquivo saida.png. Use a API de fila do ComfyUI
(/prompt e /history).

Crie um script Python que leia um arquivo CSV (clientes.csv com
colunas nome, email, mensagem) e, para cada linha, peça pro modelo
em http://127.0.0.1:22434/v1/chat/completions (modelo "llama3.2",
api_key="haon-tunnel") classificar a mensagem como "elogio",
"reclamação" ou "dúvida". Salva o resultado em saida.csv com uma
coluna nova chamada categoria.

from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:22434/v1",
    api_key="haon-tunnel",
)

resp = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Resuma o tunelamento WebRTC em 2 frases."}],
)
print(resp.choices[0].message.content)

import requests

r = requests.post(
    "http://127.0.0.1:22434/api/generate",
    json={"model": "llama3.2", "prompt": "ping", "stream": False},
    timeout=60,
)
r.raise_for_status()
print(r.json()["response"])

async function ask(message) {
  const r = await fetch("http://127.0.0.1:22434/v1/chat/completions", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": "Bearer haon-tunnel",
    },
    body: JSON.stringify({
      model: "llama3.2",
      messages: [{ role: "user", content: message }],
    }),
  });
  const data = await r.json();
  return data.choices[0].message.content;
}

console.log(await ask("Quanto é 2 + 2?"));

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import httpx

app = FastAPI()
TUNNEL = "http://127.0.0.1:22434/v1/chat/completions"

class Q(BaseModel):
    pergunta: str

@app.post("/responder")
async def responder(q: Q):
    async with httpx.AsyncClient(timeout=60) as c:
        r = await c.post(TUNNEL, json={
            "model": "llama3.2",
            "messages": [{"role": "user", "content": q.pergunta}],
        })
    if r.status_code >= 400:
        raise HTTPException(r.status_code, r.text)
    return {"resposta": r.json()["choices"][0]["message"]["content"]}

export const COMFY_HOST = "127.0.0.1:22434";

export const COMFY_HTTP = `http://${COMFY_HOST}`;
export const COMFY_WS   = `ws://${COMFY_HOST}/ws`;

// Submete um workflow.json (formato exportado pelo ComfyUI Web)
export async function submit(workflow: object, clientId: string) {
  const r = await fetch(`${COMFY_HTTP}/prompt`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ prompt: workflow, client_id: clientId }),
  });
  return (await r.json()).prompt_id as string;
}

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:22434/v1", api_key="haon-tunnel")

resp = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "Você é um assistente conciso."},
        {"role": "user",   "content": "Liste 3 vantagens do P2P GPU sharing."},
    ],
    temperature=0.4,
    max_tokens=300,
)
print(resp.choices[0].message.content)

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="llama3.2",
    base_url="http://127.0.0.1:22434/v1",
    api_key="haon-tunnel",
    temperature=0.2,
)

print(llm.invoke("Em uma frase: o que é HAON?").content)

from flask import Flask, request, jsonify, render_template_string
import requests

app = Flask(__name__)
TUNNEL = "http://127.0.0.1:22434/v1/chat/completions"
SYSTEM = "Você é o atendente da loja. Seja simpático, conciso, sempre responda em português."

PAGE = """<!doctype html>
<title>Atendimento 24/7</title>
<style>body{font-family:sans-serif;max-width:640px;margin:2rem auto}
#log{border:1px solid #ddd;padding:1rem;height:60vh;overflow:auto}
.u{color:#06c}.b{color:#080}</style>
<h1>Atendimento da loja</h1>
<div id="log"></div>
<form id="f"><input id="i" autofocus style="width:80%"><button>Enviar</button></form>
<script>
const log=document.getElementById('log'),i=document.getElementById('i'),f=document.getElementById('f');
const hist=[];
f.onsubmit=async e=>{e.preventDefault();const t=i.value.trim();if(!t)return;i.value='';
hist.push({role:'user',content:t});
log.innerHTML+='<p class=u><b>Você:</b> '+t+'</p>';
const r=await fetch('/chat',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({hist})});
const d=await r.json();hist.push({role:'assistant',content:d.reply});
log.innerHTML+='<p class=b><b>Loja:</b> '+d.reply+'</p>';log.scrollTop=log.scrollHeight};
</script>"""

@app.get("/")
def index():
    return render_template_string(PAGE)

@app.post("/chat")
def chat():
    hist = request.json.get("hist", [])
    msgs = [{"role": "system", "content": SYSTEM}, *hist]
    r = requests.post(TUNNEL, json={"model": "llama3.2", "messages": msgs}, timeout=60)
    r.raise_for_status()
    return jsonify(reply=r.json()["choices"][0]["message"]["content"])

if __name__ == "__main__":
    app.run(port=5000)