TLM_AI / server.py
ItamarMordo's picture
Update server.py
367b667 verified
Raw History Blame Contribute Delete
10.9 kB
import uvicorn
import json
import logging
import sqlite3
import os
import re
from typing import List, Optional, Literal
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from huggingface_hub import InferenceClient
# --- Configuration ---
MODEL_ID = "meta-llama/Meta-Llama-3-8B-Instruct"
PORT = int(os.environ.get("PORT", 8000))
HOST = "0.0.0.0"
DB_FILE = "chatbot.db"
JSON_SOURCE = "database.json"
HF_TOKEN = os.environ.get("HF_TOKEN")
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
app = FastAPI(title="Hebrew Smart Home Technician", version="10.4.0")
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
# ---------------------------------
# --- מילון מונחים לחיפוש ---
SEARCH_MAP = {
"בקר": ["ESP32", "Controller", "Main Board", "DevKit"],
"מסך": ["Nextion", "Display", "Screen", "HMI", "Nextion Screen"],
"ממיר": ["Level Shifter", "LevelConvertor", "BOB", "Converter"],
"לוח": ["Student Board", "PCB", "Board"],
"שרטוט": ["Schematic", "Connections", "Pin", "Net"],
"חיבור": ["Connect", "Wire", "Signal", "RX", "TX", "HV", "LV"],
"תקלה": ["Error", "Problem", "Fix"],
"זרם": ["ACS712", "Sensor"],
"מתח": ["3.3V", "5V", "VIN", "Power"]
}
def init_db():
conn = sqlite3.connect(DB_FILE)
cursor = conn.cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS knowledge (id INTEGER PRIMARY KEY, topic TEXT, content TEXT)')
cursor.execute('CREATE TABLE IF NOT EXISTS history (id INTEGER PRIMARY KEY, role TEXT, content TEXT)')
cursor.execute('SELECT count(*) FROM knowledge')
if cursor.fetchone()[0] == 0 and os.path.exists(JSON_SOURCE):
try:
with open(JSON_SOURCE, 'r', encoding='utf-8') as f:
data = json.load(f)
count = 0
for item in data:
if isinstance(item, dict) and 'content' in item:
cursor.execute('INSERT INTO knowledge (topic, content) VALUES (?, ?)',
(item.get('topic', 'General'), item['content']))
count += 1
conn.commit()
logger.info(f"✅ Loaded {count} items from database.json")
except Exception as e:
logger.error(f"❌ Error loading JSON: {e}")
conn.close()
def expand_query(query: str) -> List[str]:
words = re.sub(r'[^\w\s]', '', query).split()
search_terms = set(words)
for w in words:
root = w[1:] if len(w) > 3 and w.startswith('ה') else w
search_terms.add(root)
for key, values in SEARCH_MAP.items():
if key in root:
search_terms.update(values)
if w.isdigit():
search_terms.add(w)
search_terms.add(f"D{w}")
return list(search_terms)
def simplify_schematic_text(text: str) -> str:
"""
Cleans up the English schematic text and translates key terms to Hebrew
for better readability in the chat.
"""
text = re.sub(r'\([A-Za-z0-9_\-]+\)', '', text)
text = text.replace("D16_or_RX2", "RX2")
text = text.replace("D17_or_TX2", "TX2")
text = text.replace("3V3", "3.3V")
replacements = {
"Level Shifter": "ממיר רמות",
"Student Board": "לוח תלמיד",
"Nextion Screen": "מסך Nextion",
"ESP32": "בקר ESP32",
"connects to": "--- מחובר אל --->",
"Pin": "פין",
"GND": "הארקה (GND)",
"VIN": "מתח כניסה (VIN)"
}
for eng, heb in replacements.items():
text = re.sub(r'\b' + re.escape(eng) + r'\b', heb, text)
text = text.replace("Pin Pin", "פין")
text = text.replace("פין פין", "פין")
text = re.sub(r'\s+', ' ', text).strip()
return text
def query_knowledge_base(query: str) -> str:
conn = sqlite3.connect(DB_FILE)
cursor = conn.cursor()
search_terms = expand_query(query)
logger.info(f"🔍 Searching for: {search_terms}")
is_general_schematic_query = any(x in query for x in ["הכל", "כל החיבורים", "שרטוט", "מה מחובר", "לאן", "פינים"])
is_definition_query = any(x in query for x in ["מה זה", "הסבר", "מידע על", "תאר"])
results = []
seen_ids = set()
for term in search_terms:
cursor.execute("SELECT id, content, topic FROM knowledge WHERE content LIKE ? OR topic LIKE ?", (f'%{term}%', f'%{term}%'))
rows = cursor.fetchall()
for row_id, content, topic in rows:
if row_id not in seen_ids:
score = 1
if "Schematic" in content:
score += 100
elif term.lower() in topic.lower():
score += 10
results.append((score, content))
seen_ids.add(row_id)
if not results and is_general_schematic_query:
cursor.execute("SELECT id, content, topic FROM knowledge WHERE content LIKE '%Schematic%'")
row = cursor.fetchone()
if row:
results.append((100, row[1]))
conn.close()
results.sort(key=lambda x: x[0], reverse=True)
if results:
raw_content = results[0][1]
if "Schematic" in raw_content:
lines = raw_content.split('\n')
relevant_lines = []
if is_definition_query and not is_general_schematic_query:
return simplify_schematic_text(raw_content)
if is_general_schematic_query:
for line in lines:
if "connect" in line.lower():
relevant_lines.append(line.strip())
else:
target_terms = [t.lower() for t in search_terms if len(t) > 1]
for line in lines:
if "connect" in line.lower() and any(t in line.lower() for t in target_terms):
relevant_lines.append(line.strip())
clean_text = simplify_schematic_text("\n".join(relevant_lines))
return f"להלן המידע הטכני שנמצא:\n{clean_text}"
return raw_content
return ""
def save_message(role: str, content: str):
try:
conn = sqlite3.connect(DB_FILE)
cursor = conn.cursor()
cursor.execute("INSERT INTO history (role, content) VALUES (?, ?)", (role, content))
conn.commit()
conn.close()
except: pass
class Message(BaseModel):
role: Literal["user", "assistant", "system"]
content: str
class ChatCompletionRequest(BaseModel):
messages: List[Message]
max_tokens: Optional[int] = 1024
temperature: Optional[float] = 0.4 # הועלה מעט כדי לאפשר ניסוח טבעי יותר
stream: Optional[bool] = False
@app.on_event("startup")
async def startup_event():
init_db()
logger.info("✅ Server started in API Mode")
@app.post("/v1/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
last_user_msg = next((m for m in reversed(request.messages) if m.role == "user"), None)
context = ""
if last_user_msg:
save_message("user", last_user_msg.content)
context = query_knowledge_base(last_user_msg.content)
# --- הנחיות מערכת מעודכנות: "המדריך המקצועי" ---
sys_msg = (
"תפקידך: טכנאי מומחה וחונך לפרויקט 'בית חכם תלם'.\n"
"המטרה: לעזור למשתמש להבין את החיווט והמערכת בצורה נעימה, ברורה ומקצועית.\n\n"
"הנחיות לכתיבת התשובה:\n"
"1. **היה אנושי ומועיל:** אל תפלוט רשימה יבשה. דבר אל המשתמש בגובה העיניים (למשל: 'כדי לחבר את הממיר, שים לב לחיבורים הבאים...').\n"
"2. **קבץ מידע:** אם יש מספר חיבורים הקשורים לתקשורת (RX/TX) או למתח (GND/VCC), נסה לאחד אותם למשפט ברור במקום שורות נפרדות.\n"
"3. **דיוק טכני:** הסתמך אך ורק על המידע המופיע למטה. אל תמציא חיבורים שלא קיימים.\n"
"4. השתמש בשמות הפינים באנגלית (כמו HV1, LV2, GND) כדי לשמור על דיוק.\n"
)
if context:
sys_msg += f"\n--- מידע טכני מהמערכת (השתמש בזה כדי לענות) ---\n{context}\n------------------------------------"
else:
sys_msg += "\n(לא נמצא מידע ספציפי. נסה לענות על בסיס ידע כללי אם זה רלוונטי, או בקש מהמשתמש לפרט)."
messages_payload = [msg.dict() for msg in request.messages]
if messages_payload[0]['role'] == 'system':
messages_payload[0]['content'] = sys_msg
else:
messages_payload.insert(0, {"role": "system", "content": sys_msg})
if request.stream:
async def stream_generator():
full_text = ""
try:
for chunk in client.chat_completion(
messages=messages_payload,
max_tokens=request.max_tokens,
temperature=request.temperature,
stream=True
):
delta = chunk.choices[0].delta.content
if delta:
full_text += delta
yield f"data: {json.dumps({'choices': [{'delta': {'content': delta}}]}, ensure_ascii=False)}\n\n"
save_message("assistant", full_text)
yield "data: [DONE]\n\n"
except Exception as e:
logger.error(f"API Error: {e}")
yield f"data: {json.dumps({'error': str(e)})}\n\n"
return StreamingResponse(stream_generator(), media_type="text/event-stream; charset=utf-8")
try:
response = client.chat_completion(
messages=messages_payload,
max_tokens=request.max_tokens,
temperature=request.temperature,
stream=False
)
content = response.choices[0].message.content
save_message("assistant", content)
return response
except Exception as e:
logger.error(f"API Error: {e}")
raise HTTPException(500, f"Hugging Face API Error: {str(e)}")
if __name__ == "__main__":
uvicorn.run("server:app", host=HOST, port=PORT, reload=False)