Waiting for a question...
Waiting for a question...
Thought Map
Map of Philosophical Thought
Click any node to explore deeper →
Mapping the philosophy...
"""
# ── ROUTES ────────────────────────────────────────────────────────────────────
@app.get("/", response_class=HTMLResponse)
async def root():
return HTMLResponse(content=PLAYGROUND_HTML, headers={"Cache-Control": "no-store, no-cache, must-revalidate"})
@app.get("/compare", response_class=HTMLResponse)
async def compare():
return HTMLResponse(content=HTML, headers={"Cache-Control": "no-store, no-cache, must-revalidate"})
@app.get("/info")
async def info():
return {
"philosopher_model": PHILOSOPHER_MODEL_ID,
"vllm_url": PHILOSOPHER_MODEL_URL or None,
}
async def stream_completion(question: str, system: str, oai_client, model_id: str, max_tokens: int = 1500):
"""Stream a response from any OpenAI-compatible endpoint as SSE."""
stream = oai_client.chat.completions.create(
model=model_id,
messages=[
{"role": "system", "content": system},
{"role": "user", "content": question}
],
stream=True,
max_tokens=max_tokens,
temperature=0.7,
)
for chunk in stream:
delta = chunk.choices[0].delta
if delta.content:
yield f"data: {json.dumps({'token': delta.content})}\n\n"
yield "data: [DONE]\n\n"
async def async_stream(url: str, model: str, system: str, question: str, max_tokens: int, auth_token: str):
"""Stream from any OpenAI-compatible endpoint via async httpx — never blocks the event loop."""
payload = {
"model": model,
"messages": [
{"role": "system", "content": system},
{"role": "user", "content": question}
],
"max_tokens": max_tokens,
"temperature": 0.7,
"stream": True,
}
try:
async with httpx.AsyncClient(timeout=600.0) as http:
async with http.stream(
"POST", f"{url}/chat/completions",
json=payload,
headers={"Authorization": f"Bearer {auth_token}", "Content-Type": "application/json"}
) as resp:
async for line in resp.aiter_lines():
if line.startswith("data: "):
data = line[6:].strip()
if data == "[DONE]":
break
try:
chunk = json.loads(data)
content = chunk["choices"][0]["delta"].get("content", "")
if content:
yield f"data: {json.dumps({'token': content})}\n\n"
except Exception:
pass
except Exception as e:
print(f"async_stream error: {e}", flush=True)
yield "data: [DONE]\n\n"
async def hf_stream(url: str, system: str, question: str, max_tokens: int):
"""Legacy wrapper — kept for HF endpoints."""
async for chunk in async_stream(url, "tgi", system, question, max_tokens, HF_TOKEN):
yield chunk
async def async_stream_messages(url: str, model: str, messages: list, max_tokens: int, auth_token: str):
"""Stream from any OpenAI-compatible endpoint with a full messages array (multi-turn)."""
payload = {
"model": model,
"messages": messages,
"max_tokens": max_tokens,
"temperature": 0.7,
"stream": True,
}
try:
async with httpx.AsyncClient(timeout=600.0) as http:
async with http.stream(
"POST", f"{url}/chat/completions",
json=payload,
headers={"Authorization": f"Bearer {auth_token}", "Content-Type": "application/json"}
) as resp:
async for line in resp.aiter_lines():
if line.startswith("data: "):
data = line[6:].strip()
if data == "[DONE]":
break
try:
chunk = json.loads(data)
content = chunk["choices"][0]["delta"].get("content", "")
if content:
yield f"data: {json.dumps({'token': content})}\n\n"
except Exception:
pass
except Exception as e:
print(f"async_stream_messages error: {e}", flush=True)
yield "data: [DONE]\n\n"
@app.post("/stream/base")
async def stream_base(request: Request):
body = await request.json()
question = body.get("question", "")
max_tokens = int(body.get("max_tokens", 600))
if BASE_MODEL_URL:
return StreamingResponse(
async_stream(BASE_MODEL_URL, "tgi", QUICK_SYSTEM, question, max_tokens, HF_TOKEN),
media_type="text/event-stream"
)
if TOGETHER_KEY:
return StreamingResponse(
async_stream(TOGETHER_BASE, QWEN_BASE_MODEL, QUICK_SYSTEM, question, max_tokens, TOGETHER_KEY),
media_type="text/event-stream"
)
return StreamingResponse(
stream_completion(question, QUICK_SYSTEM, base_client, BASE_MODEL_ID, max_tokens=max_tokens),
media_type="text/event-stream"
)
@app.post("/stream/philosopher")
async def stream_philosopher(request: Request):
body = await request.json()
question = body.get("question", "")
max_tokens = int(body.get("max_tokens", 1500))
if PHILOSOPHER_MODEL_URL:
return StreamingResponse(
async_stream(PHILOSOPHER_MODEL_URL, "tgi", PHILOSOPHER_SYSTEM, question, max_tokens, HF_TOKEN),
media_type="text/event-stream"
)
return StreamingResponse(
stream_completion(question, PHILOSOPHER_SYSTEM, phil_client, PHILOSOPHER_MODEL_ID, max_tokens=max_tokens),
media_type="text/event-stream"
)
@app.post("/stream/chat")
async def stream_chat(request: Request):
"""Multi-turn chat against the philosopher fine-tune. Body: {messages: [...], max_tokens}."""
body = await request.json()
messages = body.get("messages", [])
max_tokens = int(body.get("max_tokens", 1500))
# Prepend the philosopher system prompt if not already present
if not messages or messages[0].get("role") != "system":
messages = [{"role": "system", "content": PHILOSOPHER_SYSTEM}] + messages
if PHILOSOPHER_MODEL_URL:
return StreamingResponse(
async_stream_messages(PHILOSOPHER_MODEL_URL, "tgi", messages, max_tokens, HF_TOKEN),
media_type="text/event-stream"
)
# Fallback to the OpenAI-compatible client (sync) — used when no PHILOSOPHER_MODEL_URL set
async def _gen():
stream = phil_client.chat.completions.create(
model=PHILOSOPHER_MODEL_ID,
messages=messages,
stream=True,
max_tokens=max_tokens,
temperature=0.7,
)
for chunk in stream:
delta = chunk.choices[0].delta
if delta.content:
yield f"data: {json.dumps({'token': delta.content})}\n\n"
yield "data: [DONE]\n\n"
return StreamingResponse(_gen(), media_type="text/event-stream")
@app.post("/dag")
async def get_dag(request: Request):
"""Return a JSON graph structure for the philosophical thought map."""
body = await request.json()
question = body.get("question", "")
def extract_json(text: str):
"""Extract JSON from model response, handling markdown wrapping."""
text = text.strip()
if "```" in text:
parts = text.split("```")
for part in parts:
if part.startswith("json"):
part = part[4:]
part = part.strip()
if part.startswith("{"):
return json.loads(part)
# Try direct parse
start = text.find("{")
end = text.rfind("}") + 1
if start >= 0 and end > start:
return json.loads(text[start:end])
return json.loads(text)
# Use OpenAI gpt-4o-mini — fast, reliable, no cold start
if client is None:
return JSONResponse(content={"error": "DAG unavailable — OPENAI_API_KEY not configured"}, status_code=503)
try:
def _call():
return client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": DAG_SYSTEM},
{"role": "user", "content": question}
],
max_tokens=1200,
temperature=0.3,
response_format={"type": "json_object"},
)
response = await asyncio.get_running_loop().run_in_executor(None, _call)
raw = response.choices[0].message.content
data = extract_json(raw)
return JSONResponse(content=data)
except Exception as e:
print(f"DAG failed: {e}", flush=True)
return JSONResponse(content={"error": str(e)}, status_code=500)
# ── PLAYGROUND HTML ───────────────────────────────────────────────────────────
PLAYGROUND_HTML = """