</> AI Engineering Crash Course

# pip install openai chromadb numpy
import os, json, time
from openai import OpenAI

client = OpenAI()  # OPENAI_API_KEY a környezeti változóból
print("OpenAI client initialized")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Te egy webshop ügyfélszolgálati asszisztens vagy. Rövid, pontos válaszokat adj."},
        {"role": "user", "content": "Mennyi idő alatt érkezik meg a csomag?"}
    ]
)

print(response.choices[0].message.content)

SYSTEM_INSTRUCTIONS = """
Te a WebShop Pro ügyfélszolgálati botja vagy.
Szabályok:
1. Csak a megadott tudásbázisból válaszolj
2. Ha nem tudod: "Továbbítom a csapatnak."
3. Soha ne találj ki információt
4. Mindig magyarul válaszolj
"""

kerdes = "Vissza tudok küldeni egy 14 napja vásárolt terméket?"
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM_INSTRUCTIONS},
        {"role": "user", "content": kerdes}
    ]
)
print(response.choices[0].message.content)

import json

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Válaszolj JSON-ban a megadott sémának megfelelően."},
        {"role": "user", "content": "Mennyibe kerül a szállítás?"}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "support_answer",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "answer": {"type": "string"},
                    "category": {"type": "string", "enum": ["szallitas", "visszakuldes", "garancia", "egyeb"]},
                    "confidence": {"type": "number"}
                },
                "required": ["answer", "category", "confidence"],
                "additionalProperties": False
            }
        }
    }
)

result = json.loads(response.choices[0].message.content)
print(json.dumps(result, indent=2, ensure_ascii=False))

# Tool definíció
tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Rendelés státuszának lekérdezése rendelésszám alapján",
        "parameters": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string", "description": "Rendelésszám, pl. WSP-12345"}
            },
            "required": ["order_id"]
        }
    }
}]

# Mock implementáció
def get_order_status(order_id):
    orders = {
        "WSP-12345": {"status": "szállítás alatt", "eta": "2025-01-15"},
        "WSP-67890": {"status": "kézbesítve", "delivered": "2025-01-10"},
    }
    return orders.get(order_id, {"status": "nem található"})

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Te a WebShop Pro support bot vagy."},
        {"role": "user", "content": "Mi a helyzet a WSP-12345 rendeléssel?"}
    ],
    tools=tools,
    tool_choice="auto"
)

# Ha a modell tool-t hív, a tool_calls listán kapjuk vissza, content=None
tool_calls = response.choices[0].message.tool_calls
if tool_calls:
    for tc in tool_calls:
        args = json.loads(tc.function.arguments)
        result = get_order_status(**args)
        print(f"Tool {tc.function.name} →", result)
else:
    print(response.choices[0].message.content)

# Koszinusz-hasonlóság demó
import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Szimulált embeddingek (valóságban 1536 dimenziós)
vec_szallitas = np.array([0.8, 0.2, 0.1])
vec_csomag    = np.array([0.7, 0.3, 0.1])
vec_vissza    = np.array([0.1, 0.2, 0.8])

print(f"szállítás vs csomag:       {cosine_similarity(vec_szallitas, vec_csomag):.2f}")
print(f"szállítás vs visszaküldés: {cosine_similarity(vec_szallitas, vec_vissza):.2f}")

emb_response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Mennyi idő alatt érkezik meg a csomag?"
)

vector = emb_response.data[0].embedding
print(f"Dimenzió: {len(vector)}")
print(f"Első 5 érték: {vector[:5]}")
print(f"Token használat: {emb_response.usage.total_tokens}")

import chromadb

# Lokális ChromaDB (in-memory demo)
chroma_client = chromadb.Client()

collection = chroma_client.create_collection(
    name="webshop_docs",
    metadata={"description": "WebShop Pro dokumentumok"}
)

# Dokumentumok hozzáadása
collection.add(
    documents=[
        "A standard szállítás 3-5 munkanapot vesz igénybe.",
        "A visszaküldési határidő 30 nap a vásárlástól számítva.",
        "A garancia 2 év, a számla szükséges hozzá."
    ],
    ids=["doc1", "doc2", "doc3"]
)

print(f"Dokumentumok száma: {collection.count()}")

# Keresés a gyűjteményben
results = collection.query(
    query_texts=["meddig tarthatja meg a terméket?"],
    n_results=2
)

print("Legjobb találatok:")
for doc, dist in zip(results["documents"][0], results["distances"][0]):
    print(f"  [{dist:.3f}] {doc}")

def chunk_text(text, chunk_size=200, overlap=50):
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunks.append(text[start:end])
        start += chunk_size - overlap
    return chunks

szabalyzat = """A WebShop Pro visszaküldési szabályzata:
1. A terméket a vásárlástól számított 30 napon belül vissza lehet küldeni.
2. A terméknek eredeti állapotban kell lennie.
3. A csomagolásnak érintetlennek kell lennie.
4. A visszaküldés ingyenes, a futár viszi a csomagot.
5. A visszatérítés 5 munkanapon belül megtörténik.
6. Elektromos termékekre a garancia 2 év érvényes."""

chunks = chunk_text(szabalyzat, chunk_size=150, overlap=30)
for i, chunk in enumerate(chunks):
    print(f"--- Chunk {i+1} ({len(chunk)} chars) ---")
    print(chunk[:80] + "...")

# WebShop Pro tudásbázis
DOCUMENTS = [
    {"id": "szallitas", "title": "Szállítási tájékoztató",
     "text": """A WebShop Pro szállítási lehetőségei:
- Standard szállítás: 990 Ft, 3-5 munkanap
- Expressz szállítás: 2490 Ft, 1-2 munkanap
- Aznapi kézbesítés: 3990 Ft, rendelés 12:00-ig
- Ingyenes szállítás 15000 Ft feletti rendelések esetén
- Nemzetközi szállítás: 5-10 munkanap"""},
    {"id": "visszakuldes", "title": "Visszaküldési szabályzat",
     "text": """Visszaküldési feltételek:
- 30 nap a vásárlástól
- Eredeti csomagolás
- Érintetlen állapot
- Ingyenes visszaküldés
- 5 munkanapon belüli visszatérítés
- Elektromos termékekre 2 év garancia"""},
    {"id": "garancia", "title": "Garanciális feltételek",
     "text": """Garanciális feltételek:
- 2 év garancia minden elektromos termékre
- Számla szükséges
- A gyártói hibát a szerviz állapítja meg
- 14 napon belül csere vagy javítás
- Nem fedett: szándékos rongálás, vízrongálás"""},
    {"id": "faq", "title": "Gyakori kérdések",
     "text": """GYIK:
- Nyomon követhető a csomag? Igen, a rendeléskor kapott linken.
- Lehet különböző címre szállítani? Igen, a pénztárnál megadható.
- Elfogadtok utalványt? Igen, WebShop Pro utalvány és kupon is.
- Telefonon is lehet rendelni? Igen, hétköznap 8-16 óra között."""}
]

# Chunking + metadata
all_chunks = []
for doc in DOCUMENTS:
    chunks = chunk_text(doc["text"], chunk_size=200, overlap=50)
    for i, chunk in enumerate(chunks):
        all_chunks.append({
            "id": f"{doc['id']}_chunk{i}",
            "text": chunk,
            "source": doc["title"]
        })

print(f"Dokumentumok: {len(DOCUMENTS)}, Chunkok: {len(all_chunks)}")

rag_collection = chroma_client.create_collection(name="webshop_rag")

rag_collection.add(
    documents=[c["text"] for c in all_chunks],
    ids=[c["id"] for c in all_chunks],
    metadatas=[{"source": c["source"]} for c in all_chunks]
)

print(f"Indexed chunks: {rag_collection.count()}")

def retrieve(query, n_results=3):
    results = rag_collection.query(
        query_texts=[query],
        n_results=n_results
    )
    docs = results["documents"][0]
    sources = [m["source"] for m in results["metadatas"][0]]
    distances = results["distances"][0]
    return list(zip(docs, sources, distances))

# Teszt
results = retrieve("Mennyibe kerül a szállítás?")
for doc, source, dist in results:
    print(f"[{dist:.3f}] ({source})")
    print(f"  {doc[:80]}...")

def rag_query(question, n_results=3):
    # 1. RETRIEVE
    retrieved = retrieve(question, n_results=n_results)
    context = "\n\n".join([doc for doc, _, _ in retrieved])

    # 2. AUGMENT — a kontextust a system message-be tesszük,
    #    a felhasználó kérdését pedig külön user message-be.
    #    Ez biztonságosabb, mint egyetlen f-stringbe ágyazni
    #    (kevésbé vulnerable prompt injection-re).
    system_msg = f"""{SYSTEM_INSTRUCTIONS}

Tudásbázis (csak ebből válaszolj):
{context}

Ha a kérdés nem szerepel a tudásbázisban, mondd: "Ezt a kérdést továbbítom a csapatnak."""

    # 3. GENERATE
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": question}
        ]
    )
    return response.choices[0].message.content

# Teszteljük!
for q in ["Mennyibe kerül a szállítás?", "Meddig garanciás a telefon?"]:
    print(f"Q: {q}")
    print(f"A: {rag_query(q)}")
    print()

# Egyszerű eval: LLM-as-judge
def evaluate_answer(question, answer, context):
    eval_response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": """Értékeld a válasz minőségét.
Adj 0-1 közötti pontszámot:
- faithfulness: a válasz a kontextusból származik-e
- relevance: a válasz releváns-e a kérdésre
Válaszolj JSON-ban."""},
            {"role": "user", "content": f"""Kérdés: {question}
Válasz: {answer}
Kontextus: {context}"""}
        ],
        response_format={"type": "json_schema", "json_schema": {
            "name": "eval",
            "strict": True,
            "schema": {"type": "object",
                "properties": {
                    "faithfulness": {"type": "number"},
                    "relevance": {"type": "number"},
                    "reasoning": {"type": "string"}},
                "required": ["faithfulness", "relevance", "reasoning"],
                "additionalProperties": False}}}
    )
    return json.loads(eval_response.choices[0].message.content)

# Eval teszt
q = "Mennyibe kerül a szállítás?"
a = "A standard szállítás 990 Ft."
ctx = "A WebShop Pro szállítási lehetőségei: Standard: 990 Ft, 3-5 munkanap"

result = evaluate_answer(q, a, ctx)
print(json.dumps(result, indent=2, ensure_ascii=False))

# Cost és latency wrapper
def rag_query_tracked(question):
    start = time.time()

    # Retrieval (lokális, gyors)
    retrieved = retrieve(question)
    context = "\n\n".join([doc for doc, _, _ in retrieved])

    # LLM hívás (API, lassú)
    llm_start = time.time()
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"{SYSTEM_INSTRUCTIONS}\n\nTudásbázis:\n{context}"},
            {"role": "user", "content": question}
        ]
    )
    llm_time = time.time() - llm_start

    total_time = time.time() - start

    # Modellárakat konfigurációból tölts, mert idővel változhatnak.
    PRICING = {"gpt-4o": {"input_per_1m": 2.50, "output_per_1m": 10.00}}  # példaérték
    price = PRICING["gpt-4o"]
    # A response.usage tartalmazza a token számot:
    #   prompt_tokens, completion_tokens, total_tokens
    usage = response.usage
    in_cost = usage.prompt_tokens * price["input_per_1m"] / 1_000_000
    out_cost = usage.completion_tokens * price["output_per_1m"] / 1_000_000
    print(f"Retrieval: {(total_time - llm_time)*1000:.0f}ms")
    print(f"LLM: {llm_time*1000:.0f}ms")
    print(f"Total: {total_time*1000:.0f}ms")
    print(f"Tokens: {usage.prompt_tokens} in / {usage.completion_tokens} out — ${in_cost+out_cost:.5f}")
    return response.choices[0].message.content

print(rag_query_tracked("Mennyi a szállítás?"))

# streamlit run app.py
# pip install streamlit

import streamlit as st

st.title("WebShop Pro Support Bot")

# Chat history a session_state-ben
if "messages" not in st.session_state:
    st.session_state.messages = []

# Korábbi üzenetek megjelenítése
for msg in st.session_state.messages:
    st.chat_message(msg["role"]).write(msg["content"])

# Új üzenet
if prompt := st.chat_input("Kérdezz valamit..."):
    st.chat_message("user").write(prompt)
    st.session_state.messages.append({"role": "user", "content": prompt})

    # RAG válasz
    response = rag_query(prompt)
    st.chat_message("assistant").write(response)
    st.session_state.messages.append({"role": "assistant", "content": response})