Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

L-istat tal-konversazzjoni u l-ġestjoni tas-sessjonijiet

Lezzjoni 11 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. L-istat tal-konversazzjoni u l-ġestjoni tas-sessjonijiet
  2. Il-katina ma’ previous_response_id
  3. Tmexxi konversazzjonijiet multipli
  4. Meta tieħu l-kontroll tal-istorja
  5. Tibqa’ ħaj wara riavvju
  6. Punti Ewlenin

L-istat tal-konversazzjoni u l-ġestjoni tas-sessjonijiet

L-API tar-Risposti (Responses API) tappoġġja l-istat tal-konversazzjoni nativament, li jissimplifika drastikament iż-żamma tal-kuntest bejn id-diversi dawriet. M’għadekx għandek bżonn terġa’ tibni l-istorja għal kull talba: is-server jimmaniġġjaha għalik, u inti tgħaddi biss identifikatur.

Il-katina ma’ previous_response_id

Il-mekkaniżmu jinġabar f’qasam wieħed biss. Kull risposta għandha id; tgħaddiha f’previous_response_id fis-sejħa li jmiss, u l-mudell ikollu aċċess għal kull ma ġara qabel. Fl-iskambju hawn taħt, it-tielet mistoqsija—“Kif inżidhom?”—ma tagħmilx sens waħedha: il-katina tgħarraf lill-mudell li qed nitkellmu dwar il-frazzjonijiet u li l-utent huwa bidu.

from openai import OpenAI
client = OpenAI()

# L-ewwel skambju
r1 = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Int għalliem tal-matematika paċenzjuż.",
    input="Nixtieq nitgħallem dwar il-frazzjonijiet."
)
print(f"R1: {r1.output_text}")

# It-tieni skambju — il-kuntest jinżamm awtomatikament
r2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Tista' tagħtini eżempju konkret?",
    previous_response_id=r1.id
)
print(f"R2: {r2.output_text}")

# It-tielet skambju — il-konversazzjoni kollha hija aċċessibbli
r3 = client.responses.create(
    model="gpt-5.6-terra",
    input="U kif inżidhom?",
    previous_response_id=r2.id
)
print(f"R3: {r3.output_text}")
# Il-mudell jaf li ilna nitkellmu dwar il-frazzjonijiet mill-bidu

Ikkunsidra d-differenza mill-approċċ preċedenti. Mal-Chat Completions, il-konversazzjoni kienet tgħix f’lista li kont iżżomm int stess u tibgħatha mill-ġdid sħiħa f’kull dawra, bl-ispejjeż jiżdiedu hekk kif l-iskambju jitwal.

# QDEM — kellek timmaniġġja kollox int stess
history = [
    {"role": "system", "content": "Int għalliem tal-matematika."},
    {"role": "user", "content": "Nixtieq nitgħallem dwar il-frazzjonijiet."},
    {"role": "assistant", "content": "Żgur! Il-frazzjonijiet..."},
    {"role": "user", "content": "Eżempju konkret?"},
    {"role": "assistant", "content": "Ejja nieħdu pizza..."},
    {"role": "user", "content": "Kif inżidhom?"},
]
# Mibgħuta sħiħa f'kull sejħa = spejjeż li qed jiżdiedu

L-istess skambju issa jitnaqqas għal referenza waħda:

# ĠDID — ID waħda biżżejjed
r = client.responses.create(
    model="gpt-5.6-terra",
    input="Kif inżidhom?",
    previous_response_id="previous_response_id"
)
# Is-server jimmaniġġja l-istorja għalik

Tmexxi konversazzjonijiet multipli

Hekk kif l-applikazzjoni tiegħek isservi utenti multipli, il-mistoqsija ssir: liema identifikatur jappartjeni lil min? It-tweġiba hija tabella ta’ mmappjar bejn l-utent u l-aħħar response.id għall-konversazzjoni tiegħu. Il-maniġer hawn taħt jinkapsula din il-loġika: iżid previous_response_id biss jekk diġà teżisti sessjoni, imbagħad jaħżen l-identifikatur il-ġdid. Hekk, Alice u Bob jistgħu jikkonversaw parallellament mingħajr ma jitħalltu l-kuntesti tagħhom, u “sessjoni ġdida” tfisser sempliċiment li tinsa l-identifikatur attwali.

class SessionManager:
    """Maniġer tas-sessjonijiet tal-konversazzjoni."""

    def __init__(self):
        self.sessions: dict[str, str] = {}  # user_id -> last_response_id

    def send_message(self, user_id: str, message: str,
                     instructions: str = "") -> str:
        """Jibgħat messaġġ fis-sessjoni tal-utent."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Żid l-istruzzjonijiet jekk ipprovduti
        if instructions:
            kwargs["instructions"] = instructions

        # Agħmel il-katina mar-risposta preċedenti jekk teżisti
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

        response = client.responses.create(**kwargs)

        # Aħżen l-ID għad-dawra li jmiss
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Jibda konversazzjoni ġdida għall-utent."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Użu
manager = SessionManager()

# L-utent Alice
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))

# L-utent Bob (konversazzjoni indipendenti)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice tkompli l-konversazzjoni tagħha dwar Python
print(manager.send_message("alice", "How do I get started?"))

Meta tieħu l-kontroll tal-istorja

Il-katina awtomatika għandha limitu: ma tistax timmodifika dak li diġà ntqal. Jekk l-applikazzjoni tiegħek teħtieġ li tagħmel sommarju tad-dawriet preċedenti, tħassar messaġġ li fih data personali, jew terġa’ tinjetta kuntest ifformulat mill-ġdid, ibdel għal input strutturat u mmaniġġja l-lista int stess. Titlef is-sempliċità, iżda tikseb kontroll sħiħ—u l-abbiltà li ttraċċa l-inflazzjoni tat-tokens dawra wara dawra.

def manual_conversation():
    """Konversazzjoni b'ġestjoni manwali tal-istorja."""
    history = []

    while True:
        user_input = input("Int: ")
        if user_input.lower() == "quit":
            break

        history.append({"role": "user", "content": user_input})

        response = client.responses.create(
            model="gpt-5.6-terra",
            instructions="Int assistent konċiż.",
            input=history
        )

        assistant_msg = response.output_text
        history.append({"role": "assistant", "content": assistant_msg})

        print(f"Assistent: {assistant_msg}")
        print(f"  (Tokens kumulattivi: {response.usage.input_tokens})")

# manual_conversation()

Tibqa’ ħaj wara riavvju

Dizzjunarju fil-memorja jisparixxi fl-ewwel skjerament mill-ġdid (redeployment), u jieħu miegħu l-konversazzjonijiet attivi kollha. Fil-produzzjoni, ippersisti l-identifikaturi—il-fajl JSON hawn taħt juri l-prinċipju, li tista’ tadattah għad-database jew Redis tiegħek. Innota li nirreġistraw ukoll it-timestamp u l-użu tat-tokens, żewġ biċċiet ta’ informazzjoni użati għall-iskadenza u t-traċċar tal-ispejjeż, rispettivament.

import json
from datetime import datetime

class PersistentSessionManager:
    """Sessjonijiet persistenti b'backup."""

    def __init__(self, db_path: str = "sessions.json"):
        self.db_path = db_path
        self.sessions = self._load()

    def _load(self) -> dict:
        try:
            with open(self.db_path, "r") as f:
                return json.load(f)
        except FileNotFoundError:
            return {}

    def _save(self):
        with open(self.db_path, "w") as f:
            json.dump(self.sessions, f, indent=2)

    def send(self, session_id: str, message: str) -> str:
        kwargs = {"model": "gpt-5.6-terra", "input": message}

        if session_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[session_id]["last_id"]

        response = client.responses.create(**kwargs)

        self.sessions[session_id] = {
            "last_id": response.id,
            "updated_at": datetime.now().isoformat(),
            "total_tokens": response.usage.total_tokens
        }
        self._save()

        return response.output_text

Fl-aħħar nett, implimenta l-iskadenza. Mingħajr tindif, it-tabella tas-sessjonijiet tiegħek tikber biss, u utent li jirritorna wara tliet ġimgħat ikompli konversazzjoni li ma jiftakarhiex aktar. Erbgħa u għoxrin siegħa huwa punt tat-tluq raġonevoli, aġġustabbli skont il-każ ta’ użu tiegħek.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Ineħħi s-sessjonijiet skaduti."""
    now = datetime.now()
    active = {}

    for sid, data in sessions.items():
        updated = datetime.fromisoformat(data["updated_at"])
        if now - updated < timedelta(hours=max_age_hours):
            active[sid] = data

    deleted = len(sessions) - len(active)
    if deleted > 0:
        print(f"{deleted} sessjoni(jiet) skaduta mneħħija")

    return active

Biex nagħmlu sommarju ta’ dawn l-għażliet: uża previous_response_id għal konversazzjonijiet sempliċi—hija l-aktar effiċjenti; ibdel għal input strutturat meta jkollok bżonn timmodifika l-istorja; aħżen response.id b’mod affidabbli, f’database minflok fil-memorja; naddaf is-sessjonijiet mhux attivi; u mmonitorja t-tokens kumulattivi, inkella l-kontijiet jaqbduk.

Punti Ewlenin

  • previous_response_id jagħmel il-katina tar-risposti awtomatikament mingħajr ma jerġa’ jibgħat l-istorja
  • Kull risposta għandha id uniku użabbli għall-katina
  • Immaniġġja sessjonijiet multipli b’dizzjunarju user_id -> response_id
  • L-input strutturat (lista ta’ messaġġi) joffri aktar kontroll fuq l-istorja
  • Implimenta l-persistenza u l-iskadenza tas-sessjonijiet fil-produzzjoni