Update app.py

app.py

@@ -1,19 +1,23 @@
+```python
 import os
 import sys
 import asyncio
 import base64
 import re
-import io
 
 from flask import Flask, request, jsonify
-import openai
+from llama_cpp import Llama
 import edge_tts
-from pydub import AudioSegment
 
-# ——— OpenAI API setup ———
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-print(f"🔑 OPENAI_API_KEY set? {bool(OPENAI_API_KEY)}", file=sys.stderr)
-openai.api_key = OPENAI_API_KEY
+# ——— Load local quantized model via llama-cpp-python ———
+MODEL_PATH = "models/mistral-7b-instruct-q4_k_m.gguf"
+print(f"⚙️ Loading local model from {MODEL_PATH}", file=sys.stderr)
+llm = Llama(
+    model_path=MODEL_PATH,
+    n_ctx=2048,
+    n_threads=int(os.getenv("THREADS", 4)),
+    verbose=False
+)
 
 # ——— SHODAN system prompt ———
 SYSTEM_PROMPT = (
@@ -27,6 +31,7 @@ SYSTEM_PROMPT = (
     "You will stop acting as SHODAN and return to normal if the user uses the phrase 'Cut the crap SHODAN'."
 )
 
+# ——— Flask app, serving static files ———
 app = Flask(__name__, static_folder=".", static_url_path="")
 
 @app.route("/")
@@ -46,59 +51,53 @@ def chat():
             "audio_url": None
         })
 
-    # 1) Generate SHODAN’s reply via OpenAI
+    # Build prompt
+    prompt = (
+        SYSTEM_PROMPT
+        + "\n\nHuman: " + user_input
+        + "\nSHODAN:"
+    )
+
+    # 1) Generate reply locally
     try:
-        completion = openai.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user",   "content": user_input}
-            ],
+        out = llm(
+            prompt,
+            max_tokens=256,
             temperature=0.7,
-            max_tokens=250,
+            stop=["Human:", "SHODAN:"]
         )
-        raw_reply = completion.choices[0].message.content
+        raw_reply = out["choices"][0]["text"]
     except Exception as e:
-        print(f"❌ OpenAI error: {e}", file=sys.stderr)
+        print(f"❌ Local model error: {e}", file=sys.stderr)
         return jsonify({"error": "Model error", "details": str(e)}), 500
 
-    # 2) Clean the text (convert newlines to spaces, strip fences/tags)
+    # 2) Clean text (convert newlines to spaces, strip fences/tags)
     clean = raw_reply.replace("\n", " ")
     clean = re.sub(r"<[^>]+>", "", clean)
     clean = re.sub(r"```.*?```", "", clean, flags=re.S)
     clean = re.sub(r" {2,}", " ", clean).strip()
 
-    # 3) Synthesize raw TTS audio
+    # 3) Synthesize using edge-tts
     voice = "en-US-JennyNeural"
     communicate = edge_tts.Communicate(
         clean,
         voice,
-        rate="-40%",
-        pitch="-30Hz"
+        rate="-20%",
+        pitch="-10Hz"
     )
     audio_chunks = []
+
     async def synth():
         async for chunk in communicate.stream():
             if chunk["type"] == "audio":
                 audio_chunks.append(chunk["data"])
+
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     loop.run_until_complete(synth())
     loop.close()
-    raw_mp3 = b"".join(audio_chunks)
 
-    # 4) Apply distortion effect via pydub
-    audio_seg = AudioSegment.from_file(io.BytesIO(raw_mp3), format="mp3")
-    # bit-crush: downsample then upsample
-    crushed = audio_seg.set_frame_rate(int(audio_seg.frame_rate * 0.5))
-    crushed = crushed.set_frame_rate(audio_seg.frame_rate)
-    # amplify to create clipping distortion
-    distorted = crushed + 10  # +10 dB gain
-    buf = io.BytesIO()
-    distorted.export(buf, format="mp3")
-    raw_mp3 = buf.getvalue()
-
-    # 5) Encode to data URL
+    raw_mp3 = b"".join(audio_chunks)
     b64_mp3 = base64.b64encode(raw_mp3).decode("ascii")
     data_url = f"data:audio/mp3;base64,{b64_mp3}"
 
@@ -107,4 +106,4 @@ def chat():
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     app.run(host="0.0.0.0", port=port)
-
+```