Upload folder using huggingface_hub

Agent.md

@@ -0,0 +1,190 @@
+# Agent.md
+
+## 1. Deployment Configuration
+
+### Target Space
+- **Profile:** `AUXteam`  
+- **Space:** `tiny_factory`  
+- **Full Identifier:** `AUXteam/tiny_factory`  
+- **Frontend Port:** `7860` (mandatory for all Hugging Face Spaces)
+
+### Deployment Method
+Choose the correct SDK based on the app type based on the codebase language:
+
+- **Gradio SDK** — for Gradio applications  
+- **Streamlit SDK** — for Streamlit applications  
+- **Docker SDK** — for all other applications (recommended default for flexibility)
+
+### HF Token
+- The environment variable **`$HF_TOKEN` will always be provided at execution time**.
+- Never hardcode the token. Always read it from the environment.
+- All monitoring and log‑streaming commands rely on `$HF_TOKEN`.
+
+### Required Files
+- `Dockerfile` (or `app.py` for Gradio/Streamlit SDKs)
+- `README.md` with Hugging Face YAML frontmatter:
+  ```yaml
+  ---
+  title: <APP NAME>
+  sdk: docker | gradio | streamlit
+  app_port: 7860
+  ---
+  ```
+- `.hfignore` to exclude unnecessary files
+- This `Agent.md` file (must be committed before deployment)
+
+---
+
+## 2. API Exposure and Documentation
+
+### Mandatory Endpoints
+Every deployment **must** expose:
+
+- **`/health`**  
+  - Returns HTTP 200 when the app is ready.  
+  - Required for Hugging Face to transition the Space from *starting* → *running*.
+
+- **`/api-docs`**  
+  - Documents **all** available API endpoints.  
+  - Must be reachable at:  
+    `https://HF_PROFILE-tiny_factory.hf.space/api-docs`
+
+### Functional Endpoints
+Document each endpoint here. For every endpoint, include:
+
+- **Method:** GET/POST/PUT/DELETE  
+- **Path:** `/predict`, `/generate`, `/upload`, etc.  
+- **Purpose:** What the endpoint does  
+- **Request Example:** JSON or query parameters  
+- **Response Example:** JSON schema or example payload  
+
+Example format:
+
+```
+### /predict
+- Method: POST
+- Purpose: Run model inference
+- Request:
+  {
+    "text": "hello world"
+  }
+- Response:
+  {
+    "prediction": "…"
+  }
+```
+
+All endpoints listed here **must** appear in `/api-docs`.
+
+---
+
+## 3. Deployment Workflow
+
+### Standard Deployment Command
+After any code change, run:
+
+```bash
+hf upload AUXteam/tiny_factory --repo-type=space
+```
+
+This command must be executed **after updating and committing Agent.md**.
+
+### Deployment Steps
+1. Ensure all code changes are committed.  
+2. Ensure `Agent.md` is updated and committed.  
+3. Run the upload command.  
+4. Wait for the Space to build.  
+5. Monitor logs (see next section).  
+6. When the Space is running, execute all test cases.
+
+### Continuous Deployment Rule
+After **every** relevant edit (logic, dependencies, API changes):
+
+- Update `Agent.md`
+- Redeploy using the upload command
+- Re-run all test cases
+- Confirm `/health` and `/api-docs` are functional
+
+This applies even for long-running projects.
+
+---
+
+## 4. Monitoring and Logs
+
+### Build Logs (SSE)
+```bash
+curl -N \
+  -H "Authorization: Bearer $HF_TOKEN" \
+  "https://huggingface.co/api/spaces/AUXteam/tiny_factory/logs/build"
+```
+
+### Run Logs (SSE)
+```bash
+curl -N \
+  -H "Authorization: Bearer $HF_TOKEN" \
+  "https://huggingface.co/api/spaces/AUXteam/tiny_factory/logs/run"
+```
+
+### Notes
+- If the Space stays in *starting* for too long, `/health` is usually failing.  
+- If the Space times out after ~30 minutes, check logs immediately.  
+- Fix issues, commit changes, redeploy.
+
+---
+
+## 5. Test Run Cases (Mandatory After Every Deployment)
+
+These tests ensure the agentic system can verify the deployment automatically.
+
+### 1. Health Check
+```
+GET https://HF_PROFILE-tiny_factory.hf.space/health
+Expected: HTTP 200, body: {"status": "ok"} or similar
+```
+
+### 2. API Docs Check
+```
+GET https://HF_PROFILE-tiny_factory.hf.space/api-docs
+Expected: HTTP 200, valid documentation UI or JSON spec
+```
+
+### 3. Functional Endpoint Tests
+For each endpoint documented above, define:
+
+- Example request
+- Expected response structure
+- Validation criteria (e.g., non-empty output, valid JSON)
+
+Example:
+
+```
+POST https://HF_PROFILE-tiny_factory.hf.space/predict
+Payload:
+{
+  "text": "test"
+}
+Expected:
+- HTTP 200
+- JSON with key "prediction"
+- No error fields
+```
+
+### 4. End-to-End Behaviour
+- Confirm the UI loads (if applicable)
+- Confirm API endpoints respond within reasonable time
+- Confirm no errors appear in run logs
+
+---
+
+## 6. Maintenance Rules
+
+- `Agent.md` must always reflect the **current** deployment configuration, API surface, and test cases.
+- Any change to:
+  - API routes  
+  - Dockerfile  
+  - Dependencies  
+  - App logic  
+  - Deployment method  
+  requires updating this file.
+- This file must be committed **before** every deployment.
+- This file is the operational contract for autonomous agents interacting with the project.

README.md

@@ -1,29 +1,12 @@
 ---
-title: Deep Persona Factory
-emoji: 🎭
+title: Tiny Factory
+emoji: 💻
 colorFrom: yellow
 colorTo: gray
-sdk: docker
-app_port: 7860
+sdk: gradio
+sdk_version: 6.3.0
+app_file: app.py
 pinned: false
 ---
 
-# Deep Persona Factory
-
-Deep Persona Factory is a specialized simulation engine for persona generation and social content testing.
-
-## Features
-- **Social Network Engine:** Graph-based modeling and influence propagation.
-- **Prediction Engine:** ML and LLM-based engagement scoring.
-- **Deep Persona Generation:** Sequential enrichment for high-fidelity character profiles.
-- **API Documentation:** Accessible via \`/api-docs\`.
-- **Health Check:** Accessible via \`/health\`.
-
-## API Documentation
-The application exposes a mandatory \`/api-docs\` endpoint providing Swagger UI for all available endpoints.
-
-## Local Setup
-\`\`\`bash
-pip install -r requirements.txt
-uvicorn app:app --host 0.0.0.0 --port 7860
-\`\`\`
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,248 +1,181 @@
 import sys
 import os
-from fastapi import FastAPI
-from fastapi.responses import RedirectResponse
 import gradio as gr
 import json
-import glob
-from deeppersona.factory import DeepPersonaFactory
-from deeppersona.utils.semantics import select_best_persona, select_relevant_personas_utility
-from deeppersona.simulation_manager import SimulationManager, SimulationConfig
-from deeppersona.agent.social_types import Content
-from huggingface_hub import hf_hub_download, upload_file
-
-HF_TOKEN = os.getenv("HF_TOKEN") 
-REPO_ID = "AUXteam/tiny_factory"
-PERSONA_BASE_FILE = "persona_base.json"
+from fastapi import FastAPI
+import uvicorn
+from pydantic import BaseModel
 
-simulation_manager = SimulationManager()
+app = FastAPI()
 
-def load_persona_base():
-    if not HF_TOKEN:
-        print("HF_TOKEN not found, persistence disabled.")
-        return []
-    try:
-        path = hf_hub_download(repo_id=REPO_ID, filename=PERSONA_BASE_FILE, repo_type="space", token=HF_TOKEN)
-        with open(path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except Exception as e:
-        print(f"Error loading persona base: {e}")
-        return []
+@app.get("/health")
+def health():
+    return {"status": "ok"}
 
-def save_persona_base(personas):
-    if not HF_TOKEN: return
-    try:
-        with open(PERSONA_BASE_FILE, 'w', encoding='utf-8') as f:
-            json.dump(personas, f, indent=4)
-        upload_file(
-            path_or_fileobj=PERSONA_BASE_FILE,
-            path_in_repo=PERSONA_BASE_FILE,
-            repo_id=REPO_ID,
-            repo_type="space",
-            token=HF_TOKEN
-        )
-    except Exception as e:
-        print(f"Error saving persona base: {e}")
+@app.get("/api-docs")
+def api_docs():
+    # In fastapi /docs is the swagger ui, but let's provide a JSON response as well for this specific endpoint.
+    return {"message": "API documentation is available at /docs"}
 
-def generate_personas(business_description, customer_profile, num_personas, blablador_key=None):
-    if blablador_key:
-        os.environ["BLABLADOR_API_KEY"] = blablador_key
+def extract_persona_parameters(business_description: str, customer_profile: str) -> dict:
+    from tinytroupe.openai_utils import client
     
-    context = f"Business: {business_description}\nTarget: {customer_profile}"
-    factory = DeepPersonaFactory(context=context)
+    system_prompt = """
+    You are an expert persona parameter extractor. 
+    Based on the provided business description and customer profile, you must deduce and generate 10 specific parameters needed for a deep persona generator.
+    The parameters are:
+    - `age` (float): The age of the persona.
+    - `gender` (str): The gender of the persona.
+    - `occupation` (str): The occupation of the persona.
+    - `city` (str): The city of the persona.
+    - `country` (str): The country of the persona.
+    - `custom_values` (str): The personal values of the persona.
+    - `custom_life_attitude` (str): The life attitude of the persona.
+    - `life_story` (str): A brief life story of the persona.
+    - `interests_hobbies` (str): Interests and hobbies of the persona.
+    - `attribute_count` (float): Attribute richness, default to 200.
+
+    You must return a valid JSON object containing exactly these keys.
+    """
     
-    # Generate personas
-    generated = factory.generate_people(number_of_people=int(num_personas))
+    user_prompt = f"Business Description: {business_description}\nCustomer Profile: {customer_profile}\n\nReturn the 10 parameters as JSON."
     
-    # Store in base
-    base = load_persona_base()
-    for p in generated:
-        base.append({
-            "name": p.name,
-            "persona": p._persona,
-            "minibio": p.minibio()
-        })
-    save_persona_base(base)
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt}
+    ]
     
-    return [p._persona for p in generated]
-
-def find_best_persona(criteria):
-    base = load_persona_base()
-    if not base: return {"error": "No personas in base"}
+    api_client = client()
+    response = api_client.send_message(messages, response_format={"type": "json_object"})
     
-    # Simple semantic search using the utility
-    best = select_best_persona(base, criteria)
-    return best
-
-def identify_personas(context):
+    if response and "content" in response:
+        try:
+            # Attempt to parse it if the model returned string json
+            import json
+            import tinytroupe.utils as utils
+            extracted_json = utils.extract_json(response["content"])
+            
+            # Ensure all keys are present
+            required_keys = ['age', 'gender', 'occupation', 'city', 'country', 'custom_values', 'custom_life_attitude', 'life_story', 'interests_hobbies', 'attribute_count']
+            
+            # If extracting JSON list vs dict
+            if isinstance(extracted_json, list) and len(extracted_json) > 0:
+                extracted_json = extracted_json[0]
+            
+            for key in required_keys:
+                if key not in extracted_json:
+                    # provide defaults for missing ones
+                    if key in ['age', 'attribute_count']:
+                        extracted_json[key] = 200 if key == 'attribute_count' else 30
+                    else:
+                        extracted_json[key] = "Unknown"
+                        
+            return extracted_json
+        except Exception as e:
+            print(f"Error parsing JSON from LLM: {e}")
+            pass
+            
+    # Fallback
+    return {
+        "age": 30,
+        "gender": "Non-binary",
+        "occupation": "Professional",
+        "city": "Metropolis",
+        "country": "Country",
+        "custom_values": "Innovation, Community",
+        "custom_life_attitude": "Optimistic",
+        "life_story": "A standard professional background with a passion for their field.",
+        "interests_hobbies": "Technology, Reading",
+        "attribute_count": 200
+    }
+
+def generate_personas(business_description, customer_profile, num_personas, blablador_api_key=None):
     """
-    Search for relevant personas across both Tresor and internal examples.
+    Generates a list of personas based on the provided inputs, utilizing a double 
+    sequential generation pipeline:
+    1. Extract parameters from context via LLM.
+    2. Generate persona using deeppersona-experience via gradio client.
     """
-    base = load_persona_base()
-    # Add example agents from disk
-    example_files = glob.glob("deeppersona/examples/agents/*.json")
-    for ef in example_files:
-        try:
-            with open(ef, 'r') as f:
-                data = json.load(f)
-                base.append({
-                    "name": data.get("name", "Unknown"),
-                    "persona": data.get("persona", {}),
-                    "minibio": "Example agent"
-                })
-        except: pass
-        
-    relevant = select_relevant_personas_utility(base, context)
-    return relevant
-
-# API Wrappers for SimulationManager
-def generate_social_network_api(name, persona_count, network_type, focus_group_name=None):
-    try:
-        config = SimulationConfig(name=name, persona_count=int(persona_count), network_type=network_type)
-        simulation = simulation_manager.create_simulation(config, focus_group_name=focus_group_name)
-        return {"simulation_id": simulation.id, "status": "created"}
-    except Exception as e:
-        return {"error": str(e)}
-
-def predict_engagement_api(simulation_id, content_text, format="text"):
-    try:
-        content = Content(text=content_text, format=format)
-        results = simulation_manager.predict_engagement(simulation_id, content)
-        return results
-    except Exception as e:
-        return {"error": str(e)}
-
-def start_simulation_async_api(simulation_id, content_text, format="text"):
-    try:
-        content = Content(text=content_text, format=format)
-        simulation_manager.run_simulation(simulation_id, content, background=True)
-        return {"status": "started", "simulation_id": simulation_id}
-    except Exception as e:
-        return {"error": str(e)}
-
-def get_simulation_status_api(simulation_id):
-    try:
-        sim = simulation_manager.get_simulation(simulation_id)
-        if not sim: return {"error": "Not found"}
-        return {
-            "status": sim.status,
-            "progress": sim.progress,
-            "result_ready": sim.result is not None
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
-def send_chat_message_api(simulation_id, sender, message):
-    try:
-        res = simulation_manager.chat_with_simulation(simulation_id, sender, message)
-        return res
-    except Exception as e:
-        return {"error": str(e)}
+    api_key_to_use = blablador_api_key or os.getenv("BLABLADOR_API_KEY")
 
-def get_chat_history_api(simulation_id):
-    try:
-        sim = simulation_manager.get_simulation(simulation_id)
-        if not sim: return {"error": "Not found"}
-        return sim.chat_history
-    except Exception as e:
-        return {"error": str(e)}
-
-def generate_variants_api(content_text, count=5):
-    try:
-        content = Content(text=content_text)
-        variants = simulation_manager.generate_content_variants(content, int(count))
-        return [v.text for v in variants]
-    except Exception as e:
-        return {"error": str(e)}
-
-def list_simulations_api():
-    return list(simulation_manager.simulations.keys())
-
-def list_personas_api(simulation_id):
-    try:
-        sim = simulation_manager.get_simulation(simulation_id)
-        if not sim: return []
-        return [p.name for p in sim.personas]
-    except Exception as e:
-        return {"error": str(e)}
+    if not api_key_to_use:
+        return {"error": "BLABLADOR_API_KEY not found. Please provide it in your API call or set it as a secret in the Space settings."}
 
-def get_persona_api(simulation_id, persona_name):
-    try:
-        sim = simulation_manager.get_simulation(simulation_id)
-        if not sim: return None
-        for p in sim.personas:
-            if p.name == persona_name: return p._persona
-        return None
-    except Exception as e:
-        return {"error": str(e)}
-
-def delete_simulation_api(simulation_id):
-    try:
-        success = simulation_manager.delete_simulation(simulation_id)
-        return {"success": success}
-    except Exception as e:
-        return {"error": str(e)}
-
-def export_simulation_api(simulation_id):
+    original_key = os.getenv("BLABLADOR_API_KEY")
+    os.environ["BLABLADOR_API_KEY"] = api_key_to_use
+    
     try:
-        return simulation_manager.export_simulation(simulation_id)
-    except Exception as e:
-        return {"error": str(e)}
+        from gradio_client import Client
+        
+        num_personas = int(num_personas)
+        personas_data = []
 
-def get_network_graph_api(simulation_id):
-    try:
-        sim = simulation_manager.get_simulation(simulation_id)
-        if not sim: return {"error": "Simulation not found"}
-        nodes = []
-        for p in sim.personas:
-            nodes.append({
-                "id": p.name,
-                "label": p.name,
-                "role": p._persona.get("occupation"),
-                "location": p._persona.get("residence")
-            })
-        edges = []
-        for edge in sim.network.edges:
-            edges.append({
-                "source": edge.connection_id.split('_')[0],
-                "target": edge.connection_id.split('_')[1],
-                "strength": edge.strength
+        # Step 1: Extract 10 parameters based on the high-level inputs
+        # For multiple personas, we could call this in a loop or once. 
+        # The prompt implies we want to do it in a pipeline. We'll do it per persona or once based on the prompt.
+        # Let's do it per persona to generate distinct ones, passing an index or just relying on LLM variance.
+        
+        # Connect to gradio client
+        # In a real scenario, the Hugging Face Token might be needed if the Space is private.
+        # But deeppersona-experience is public or assumed accessible.
+        client = Client("THzva/deeppersona-experience")
+        
+        for i in range(num_personas):
+            # To get variety, we can append a note about variety to the profile
+            profile_with_variance = customer_profile + f"\n\nMake this persona distinct. Persona {i+1} of {num_personas}."
+            
+            # Extract parameters using the LLM
+            params = extract_persona_parameters(business_description, profile_with_variance)
+            
+            # Step 2: Call the Gradio API with the extracted parameters
+            result = client.predict(
+                age=float(params.get("age", 30)),
+                gender=str(params.get("gender", "Non-binary")),
+                occupation=str(params.get("occupation", "Professional")),
+                city=str(params.get("city", "Metropolis")),
+                country=str(params.get("country", "Country")),
+                custom_values=str(params.get("custom_values", "Innovation, Community")),
+                custom_life_attitude=str(params.get("custom_life_attitude", "Optimistic")),
+                life_story=str(params.get("life_story", "A standard professional background with a passion for their field.")),
+                interests_hobbies=str(params.get("interests_hobbies", "Technology, Reading")),
+                attribute_count=float(params.get("attribute_count", 200)),
+                api_name="/generate_persona"
+            )
+            
+            # Note: The result from this API is a string (persona profile text)
+            personas_data.append({
+                "parameters_used": params,
+                "persona_profile": result
             })
-        return {"nodes": nodes, "edges": edges}
-    except Exception as e:
-        return {"error": str(e)}
-
-def list_focus_groups_api():
-    try:
-        return simulation_manager.list_focus_groups()
-    except Exception as e:
-        return {"error": str(e)}
+            
+        return personas_data
 
-def save_focus_group_api(name, simulation_id):
-    try:
-        sim = simulation_manager.get_simulation(simulation_id)
-        if not sim: return {"error": "Simulation not found"}
-        simulation_manager.save_focus_group(name, sim.personas)
-        return {"status": "success", "name": name}
     except Exception as e:
         return {"error": str(e)}
+        
+    finally:
+        if original_key is None:
+            if "BLABLADOR_API_KEY" in os.environ:
+                del os.environ["BLABLADOR_API_KEY"]
+        else:
+            os.environ["BLABLADOR_API_KEY"] = original_key
 
-# Gradio Interface
 with gr.Blocks() as demo:
-    gr.Markdown("<h1>Deep Persona Generator</h1>")
+    gr.Markdown("<h1>Tiny Persona Generator</h1>")
     with gr.Row():
         with gr.Column():
             business_description_input = gr.Textbox(label="What is your business about?", lines=5)
             customer_profile_input = gr.Textbox(label="Information about your customer profile", lines=5)
             num_personas_input = gr.Number(label="Number of personas to generate", value=1, minimum=1, step=1)
-            blablador_api_key_input = gr.Textbox(label="Blablador API Key (for API client use)", visible=False)
-            generate_button = gr.Button("Generate Deep Personas")
-            gr.Markdown("---")
-            gr.Markdown("<h3>Search Tresor</h3>")
-            criteria_input = gr.Textbox(label="Criteria to find best matching persona", lines=2)
-            find_button = gr.Button("Find Best Deep Persona in Tresor")
+            
+            blablador_api_key_input = gr.Textbox(
+                label="Blablador API Key (for API client use)", 
+                visible=False
+            )
+
+            generate_button = gr.Button("Generate Personas")
         with gr.Column():
-            output_json = gr.JSON(label="Output (Generated or Matched Deep Persona)")
+            output_json = gr.JSON(label="Generated Personas")
 
     generate_button.click(
         fn=generate_personas,
@@ -251,126 +184,7 @@ with gr.Blocks() as demo:
         api_name="generate_personas"
     )
 
-    find_button.click(
-        fn=find_best_persona,
-        inputs=[criteria_input],
-        outputs=output_json,
-        api_name="find_best_persona"
-    )
-
-    with gr.Tab("Identify Deep Personas API", visible=False):
-        api_id_context = gr.Textbox(label="Context")
-        api_id_btn = gr.Button("Identify Deep Personas")
-        api_id_out = gr.JSON()
-        api_id_btn.click(identify_personas, inputs=[api_id_context], outputs=api_id_out, api_name="identify_personas")
-
-    with gr.Tab("Social Network API", visible=False):
-        api_net_name = gr.Textbox(label="Network Name")
-        api_net_count = gr.Number(label="Deep Persona Count", value=10)
-        api_net_type = gr.Dropdown(choices=["scale_free", "small_world"], label="Network Type")
-        api_net_focus = gr.Textbox(label="Focus Group Name (optional)")
-        api_net_btn = gr.Button("Generate Network")
-        api_net_out = gr.JSON()
-        api_net_btn.click(generate_social_network_api, inputs=[api_net_name, api_net_count, api_net_type, api_net_focus], outputs=api_net_out, api_name="generate_social_network")
-
-    with gr.Tab("Engagement Prediction API", visible=False):
-        api_pred_sim_id = gr.Textbox(label="Simulation ID")
-        api_pred_content = gr.Textbox(label="Content Text")
-        api_pred_format = gr.Textbox(label="Format", value="text")
-        api_pred_btn = gr.Button("Predict Engagement")
-        api_pred_out = gr.JSON()
-        api_pred_btn.click(predict_engagement_api, inputs=[api_pred_sim_id, api_pred_content, api_pred_format], outputs=api_pred_out, api_name="predict_engagement")
-
-    with gr.Tab("Async Simulation API", visible=False):
-        api_async_sim_id = gr.Textbox(label="Simulation ID")
-        api_async_content = gr.Textbox(label="Content Text")
-        api_async_format = gr.Textbox(label="Format", value="text")
-        api_async_btn = gr.Button("Start Simulation")
-        api_async_out = gr.JSON()
-        api_async_btn.click(start_simulation_async_api, inputs=[api_async_sim_id, api_async_content, api_async_format], outputs=api_async_out, api_name="start_simulation_async")
-        api_status_id = gr.Textbox(label="Simulation ID")
-        api_status_btn = gr.Button("Check Status")
-        api_status_out = gr.JSON()
-        api_status_btn.click(get_simulation_status_api, inputs=[api_status_id], outputs=api_status_out, api_name="get_simulation_status")
-
-    with gr.Tab("Chat API", visible=False):
-        api_chat_sim_id = gr.Textbox(label="Simulation ID")
-        api_chat_sender = gr.Textbox(label="Sender", value="User")
-        api_chat_msg = gr.Textbox(label="Message")
-        api_chat_send_btn = gr.Button("Send Message")
-        api_chat_send_out = gr.JSON()
-        api_chat_send_btn.click(send_chat_message_api, inputs=[api_chat_sim_id, api_chat_sender, api_chat_msg], outputs=api_chat_send_out, api_name="send_chat_message")
-        api_chat_hist_btn = gr.Button("Get History")
-        api_chat_hist_out = gr.JSON()
-        api_chat_hist_btn.click(get_chat_history_api, inputs=[api_chat_sim_id], outputs=api_chat_hist_out, api_name="get_chat_history")
-
-    with gr.Tab("Content Variants API", visible=False):
-        api_var_content = gr.Textbox(label="Original Content")
-        api_var_count = gr.Number(label="Number of Variants", value=5)
-        api_var_btn = gr.Button("Generate Variants")
-        api_var_out = gr.JSON()
-        api_var_btn.click(generate_variants_api, inputs=[api_var_content, api_var_count], outputs=api_var_out, api_name="generate_variants")
-
-    with gr.Tab("List Simulations API", visible=False):
-        api_list_sim_btn = gr.Button("List Simulations")
-        api_list_sim_out = gr.JSON()
-        api_list_sim_btn.click(list_simulations_api, outputs=api_list_sim_out, api_name="list_simulations")
-
-    with gr.Tab("List Deep Personas API", visible=False):
-        api_list_per_sim_id = gr.Textbox(label="Simulation ID")
-        api_list_per_btn = gr.Button("List Deep Personas")
-        api_list_per_out = gr.JSON()
-        api_list_per_btn.click(list_personas_api, inputs=[api_list_per_sim_id], outputs=api_list_per_out, api_name="list_personas")
-
-    with gr.Tab("Get Deep Persona API", visible=False):
-        api_get_per_sim_id = gr.Textbox(label="Simulation ID")
-        api_get_per_name = gr.Textbox(label="Deep Persona Name")
-        api_get_per_btn = gr.Button("Get Deep Persona")
-        api_get_per_out = gr.JSON()
-        api_get_per_btn.click(get_persona_api, inputs=[api_get_per_sim_id, api_get_per_name], outputs=api_get_per_out, api_name="get_persona")
-
-    with gr.Tab("Delete Simulation API", visible=False):
-        api_del_sim_id = gr.Textbox(label="Simulation ID")
-        api_del_btn = gr.Button("Delete Simulation")
-        api_del_out = gr.JSON()
-        api_del_btn.click(delete_simulation_api, inputs=[api_del_sim_id], outputs=api_del_out, api_name="delete_simulation")
-
-    with gr.Tab("Export Simulation API", visible=False):
-        api_exp_sim_id = gr.Textbox(label="Simulation ID")
-        api_exp_btn = gr.Button("Export Simulation")
-        api_exp_out = gr.JSON()
-        api_exp_btn.click(export_simulation_api, inputs=[api_exp_sim_id], outputs=api_exp_out, api_name="export_simulation")
-
-    with gr.Tab("Network Graph API", visible=False):
-        api_graph_sim_id = gr.Textbox(label="Simulation ID")
-        api_graph_btn = gr.Button("Get Graph Data")
-        api_graph_out = gr.JSON()
-        api_graph_btn.click(get_network_graph_api, inputs=[api_graph_sim_id], outputs=api_graph_out, api_name="get_network_graph")
-
-    with gr.Tab("Focus Group API", visible=False):
-        api_list_fg_btn = gr.Button("List Focus Groups")
-        api_list_fg_out = gr.JSON()
-        api_list_fg_btn.click(list_focus_groups_api, outputs=api_list_fg_out, api_name="list_focus_groups")
-        api_save_fg_name = gr.Textbox(label="Focus Group Name")
-        api_save_fg_sim_id = gr.Textbox(label="Simulation ID")
-        api_save_fg_btn = gr.Button("Save Focus Group")
-        api_save_fg_out = gr.JSON()
-        api_save_fg_btn.click(save_focus_group_api, inputs=[api_save_fg_name, api_save_fg_sim_id], outputs=api_save_fg_out, api_name="save_focus_group")
-
-# FastAPI App
-app = FastAPI()
-
-@app.get("/health")
-def health_check():
-    return {"status": "ok"}
-
-@app.get("/api-docs")
-def api_docs():
-    return RedirectResponse(url="/docs")
-
-# Mount Gradio
 app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
-    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

config.ini

@@ -1,12 +1,7 @@
 [OpenAI]
 API_TYPE=helmholtz-blablador
-MODEL=alias-fast
-REASONING_MODEL=alias-fast
-FALLBACK_MODEL_LARGE=alias-large
-FALLBACK_MODEL_HUGE=alias-huge
+MODEL=alias-large
+REASONING_MODEL=alias-large
 TOP_P=1.0
-MAX_ATTEMPTS=999
-WAITING_TIME=35
-
-[Logging]
-LOGLEVEL=DEBUG
+MAX_ATTEMPTS=5
+WAITING_TIME=20

pyproject.toml

@@ -3,11 +3,11 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
-packages = ["deeppersona"]
+packages = ["tinytroupe"]
 include-package-data = true
 
 [project]
-name = "deeppersona"
+name = "tinytroupe"
 version = "0.5.2"
 authors = [
   { name="Paulo Salem", email="paulo.salem@microsoft.com" }
@@ -41,7 +41,7 @@ dependencies = [
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/microsoft/deeppersona"
+"Homepage" = "https://github.com/microsoft/tinytroupe"
 
 [tool.pytest.ini_options]
 pythonpath = [
@@ -56,4 +56,4 @@ markers = [
   "examples: mark a test as the execution of examples",
   "notebooks: mark a test as a more specific Jupyter notebook execution example",
 ]
-addopts = "--cov=deeppersona --cov-report=html --cov-report=xml"
+addopts = "--cov=tinytroupe --cov-report=html --cov-report=xml"

requirements.txt

@@ -21,7 +21,7 @@ pydantic
 textdistance
 scipy
 transformers==4.38.2
-huggingface-hub>=0.33.5
+huggingface-hub==0.22.2
 gradio_client
 fastapi
 uvicorn

test_api.py

@@ -0,0 +1,58 @@
+import pytest
+from unittest.mock import patch, MagicMock
+import os
+
+import sys
+import os
+
+# Ensure the current directory is in the path
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
+from app import extract_persona_parameters, generate_personas
+
+def test_extract_persona_parameters_fallback():
+    # If the LLM call fails or returns empty, the fallback should return
+    with patch('tinytroupe.openai_utils.client') as mock_client:
+        mock_instance = MagicMock()
+        mock_instance.send_message.return_value = None
+        mock_client.return_value = mock_instance
+        
+        result = extract_persona_parameters("Test Business", "Test Customer")
+        assert "age" in result
+        assert result["age"] == 30
+
+def test_extract_persona_parameters_success():
+    with patch('tinytroupe.openai_utils.client') as mock_client:
+        mock_instance = MagicMock()
+        mock_instance.send_message.return_value = {
+            "content": '{"age": 25, "gender": "Female", "occupation": "Engineer", "city": "NYC", "country": "USA", "custom_values": "Innovation", "custom_life_attitude": "Positive", "life_story": "A story", "interests_hobbies": "Coding", "attribute_count": 200}'
+        }
+        mock_client.return_value = mock_instance
+        
+        result = extract_persona_parameters("Tech Startup", "Young professionals")
+        assert result["age"] == 25
+        assert result["gender"] == "Female"
+        assert result["city"] == "NYC"
+
+@patch('gradio_client.Client') # Mocking gradio_client Client
+def test_generate_personas(mock_client_class):
+    mock_client_instance = MagicMock()
+    mock_client_instance.predict.return_value = "Generated persona profile text"
+    mock_client_class.return_value = mock_client_instance
+    
+    with patch('app.extract_persona_parameters') as mock_extract:
+        mock_extract.return_value = {
+            "age": 25, "gender": "Female", "occupation": "Engineer", 
+            "city": "NYC", "country": "USA", "custom_values": "Innovation", 
+            "custom_life_attitude": "Positive", "life_story": "A story", 
+            "interests_hobbies": "Coding", "attribute_count": 200
+        }
+        
+        # We need an API key to pass the check
+        result = generate_personas("Tech Startup", "Young professionals", 1, blablador_api_key="TEST_KEY")
+        
+        assert isinstance(result, list)
+        assert len(result) == 1
+        assert "parameters_used" in result[0]
+        assert "persona_profile" in result[0]
+        assert result[0]["persona_profile"] == "Generated persona profile text"

tinytroupe/agent/memory.py

@@ -88,24 +88,6 @@ class TinyMemory(TinyMentalFaculty):
         """
         raise NotImplementedError("Subclasses must implement this method.")
 
-    def store_interaction(self, interaction: Any) -> None:
-        """
-        Stores an interaction in memory.
-        """
-        self.store({"type": "interaction", "content": interaction, "simulation_timestamp": utils.pretty_datetime(datetime.now())})
-
-    def get_memory_summary(self) -> str:
-        """
-        Returns a summary of the memory.
-        """
-        raise NotImplementedError("Subclasses must implement this method.")
-
-    def consolidate_memories(self) -> None:
-        """
-        Consolidates memories (e.g., from episodic to semantic).
-        """
-        raise NotImplementedError("Subclasses must implement this method.")
-
     def summarize_relevant_via_full_scan(self, relevance_target: str, batch_size: int = 20, item_type: str = None) -> str:
         """
         Performs a full scan of the memory, extracting and accumulating information relevant to a query.

tinytroupe/agent/tiny_person.py

@@ -1,6 +1,5 @@
 from tinytroupe.agent import logger, default, Self, AgentOrWorld, CognitiveActionModel
 from tinytroupe.agent.memory import EpisodicMemory, SemanticMemory, EpisodicConsolidator
-from tinytroupe.agent.social_types import ConnectionEdge, BehavioralEvent, InfluenceProfile, Content, Reaction
 import tinytroupe.openai_utils as openai_utils
 from tinytroupe.utils import JsonSerializableRegistry, repeat_on_error, name_or_empty
 import tinytroupe.utils as utils
@@ -43,8 +42,7 @@ class TinyPerson(JsonSerializableRegistry):
 
     PP_TEXT_WIDTH = 100
 
-    serializable_attributes = ["_persona", "_mental_state", "_mental_faculties", "_current_episode_event_count", "episodic_memory", "semantic_memory", 
-                               "social_connections", "engagement_patterns", "behavioral_history", "influence_metrics", "prediction_confidence", "behavioral_traits"]
+    serializable_attributes = ["_persona", "_mental_state", "_mental_faculties", "_current_episode_event_count", "episodic_memory", "semantic_memory"]
     serializable_attributes_renaming = {"_mental_faculties": "mental_faculties", "_persona": "persona", "_mental_state": "mental_state", "_current_episode_event_count": "current_episode_event_count"}
 
     # A dict of all agents instantiated so far.
@@ -211,29 +209,6 @@ class TinyPerson(JsonSerializableRegistry):
         
         if not hasattr(self, 'stimuli_count'):
             self.stimuli_count = 0
-        
-        if not hasattr(self, 'social_connections'):
-            self.social_connections = {}
-        
-        if not hasattr(self, 'engagement_patterns'):
-            self.engagement_patterns = {
-                "content_type_preferences": {},
-                "topic_affinities": {},
-                "posting_time_preferences": {},
-                "engagement_likelihood": {}
-            }
-        
-        if not hasattr(self, 'behavioral_history'):
-            self.behavioral_history = []
-        
-        if not hasattr(self, 'influence_metrics'):
-            self.influence_metrics = InfluenceProfile()
-        
-        if not hasattr(self, 'prediction_confidence'):
-            self.prediction_confidence = 0.0
-            
-        if not hasattr(self, 'behavioral_traits'):
-            self.behavioral_traits = {}
 
         self._prompt_template_path = os.path.join(
             os.path.dirname(__file__), "prompts/tiny_person.mustache"
@@ -1819,47 +1794,3 @@ max_content_length=max_content_length,
         Clears the global list of agents.
         """
         TinyPerson.all_agents = {}
-
-    ############################################################################
-    # Social and Engagement methods
-    ############################################################################
-    
-    def calculate_engagement_probability(self, content: Content) -> float:
-        """
-        Analyze content features and return probability of engagement using the prediction engine.
-        """
-        from tinytroupe.ml_models import EngagementPredictor
-        predictor = EngagementPredictor()
-        
-        # Use the environment's network topology if available
-        network = getattr(self.environment, 'network', None)
-        
-        return predictor.predict(self, content, network)
-
-    def predict_reaction(self, content: Content) -> Reaction:
-        """
-        Determine reaction type using the LLM-based predictor.
-        """
-        from tinytroupe.llm_predictor import LLMPredictor
-        predictor = LLMPredictor()
-        
-        return predictor.predict(self, content)
-
-    def update_from_interaction(self, interaction: Any) -> None:
-        """
-        Learn from actual interactions and update patterns.
-        """
-        # interaction could be a dict with content and outcome
-        if isinstance(interaction, dict):
-            content = interaction.get("content")
-            outcome = interaction.get("outcome") # e.g. "like", "comment", "none"
-            
-            # Update patterns based on outcome
-            # This is a simplified learning mechanism
-            pass
-
-    def get_content_affinity(self, content: Content) -> float:
-        """
-        Score content relevance to persona.
-        """
-        return self.calculate_engagement_probability(content)

tinytroupe/config.ini

@@ -15,10 +15,10 @@ AZURE_API_VERSION=2023-05-15
 #
 
 # The main text generation model, used for agent responses
-MODEL=alias-fast
+MODEL=gpt-4.1-mini
 
 # Reasoning model is used when precise reasoning is required, such as when computing detailed analyses of simulation properties.
-REASONING_MODEL=alias-fast
+REASONING_MODEL=o3-mini
 
 # Embedding model is used for text similarity tasks
 EMBEDDING_MODEL=text-embedding-3-small 
@@ -31,8 +31,8 @@ TEMPERATURE=1.5
 FREQ_PENALTY=0.1
 PRESENCE_PENALTY=0.1
 TIMEOUT=480
-MAX_ATTEMPTS=999
-WAITING_TIME=35
+MAX_ATTEMPTS=5
+WAITING_TIME=1
 EXPONENTIAL_BACKOFF_FACTOR=5
 
 REASONING_EFFORT=high
@@ -90,7 +90,7 @@ QUALITY_THRESHOLD = 5
 
 
 [Logging]
-LOGLEVEL=DEBUG
+LOGLEVEL=ERROR
 # ERROR
 # WARNING
 # INFO

tinytroupe/factory/tiny_person_factory.py

@@ -180,8 +180,7 @@ class TinyPersonFactory(TinyFactory):
                         frequency_penalty:float=0.0,
                         presence_penalty:float=0.0, 
                         attempts:int=10,
-                        post_processing_func=None,
-                        deep_persona:bool=True) -> TinyPerson:
+                        post_processing_func=None) -> TinyPerson:
         """
         Generate a TinyPerson instance using OpenAI's LLM.
 
@@ -319,10 +318,6 @@ class TinyPersonFactory(TinyFactory):
         
         # create the fresh agent
         if agent_spec is not None:
-            # If deep_persona is requested, perform the second API call to enrich the persona
-            if deep_persona:
-                agent_spec = self._generate_deep_persona_internal(agent_spec)
-
             # the agent is created here. This is why the present method cannot be cached. Instead, an auxiliary method is used
             # for the actual model call, so that it gets cached properly without skipping the agent creation.
             
@@ -347,46 +342,6 @@ class TinyPersonFactory(TinyFactory):
    
     
     @config_manager.config_defaults(parallelize="parallel_agent_generation")
-    def generate_from_linkedin_profile(self, profile_data: Dict) -> TinyPerson:
-        """
-        Generate a TinyPerson from a LinkedIn profile with enriched traits.
-        """
-        description = f"Professional with headline: {profile_data.get('headline', '')}. " \
-                      f"Industry: {profile_data.get('industry', '')}. " \
-                      f"Location: {profile_data.get('location', 'Global')}. " \
-                      f"Career level: {profile_data.get('career_level', 'Mid Level')}. " \
-                      f"Summary: {profile_data.get('summary', '')}"
-        
-        return self.generate_person(agent_particularities=description)
-
-    def generate_persona_cluster(self, archetype: str, count: int) -> List[TinyPerson]:
-        """
-        Generate a cluster of personas following a specific archetype.
-        """
-        return self.generate_people(number_of_people=count, agent_particularities=f"Archetype: {archetype}")
-
-    def generate_diverse_population(self, size: int, distribution: Dict) -> List[TinyPerson]:
-        """
-        Generate a diverse population based on a distribution.
-        """
-        # distribution could specify proportions of various characteristics
-        # This is a simplified implementation
-        return self.generate_people(number_of_people=size, agent_particularities=f"Target distribution: {json.dumps(distribution)}")
-
-    def ensure_consistency(self, persona: TinyPerson) -> bool:
-        """
-        Ensure the generated persona is consistent.
-        """
-        # Implementation would involve checking traits, demographics, etc.
-        return True # Placeholder
-
-    def calculate_diversity_score(self, personas: List[TinyPerson]) -> float:
-        """
-        Calculate a diversity score for a list of personas.
-        """
-        # Placeholder for diversity metric calculation
-        return 0.5
-
     def generate_people(self, number_of_people:int=None, 
                         agent_particularities:str=None, 
                         temperature:float=1.2, 
@@ -395,8 +350,7 @@ class TinyPersonFactory(TinyFactory):
                         attempts:int=10, 
                         post_processing_func=None,
                         parallelize=None,
-                        verbose:bool=False,
-                        deep_persona:bool=True) -> list:
+                        verbose:bool=False) -> list:
         """
         Generate a list of TinyPerson instances using OpenAI's LLM.
 
@@ -436,8 +390,7 @@ class TinyPersonFactory(TinyFactory):
                                                         presence_penalty=presence_penalty,
                                                         attempts=attempts, 
                                                         post_processing_func=post_processing_func,
-                                                        verbose=verbose,
-                                                        deep_persona=deep_persona)
+                                                        verbose=verbose)
         else:
             people = self._generate_people_sequentially(number_of_people=number_of_people, 
                                                         agent_particularities=agent_particularities, 
@@ -446,8 +399,7 @@ class TinyPersonFactory(TinyFactory):
                                                         presence_penalty=presence_penalty,
                                                         attempts=attempts, 
                                                         post_processing_func=post_processing_func,
-                                                        verbose=verbose,
-                                                        deep_persona=deep_persona)
+                                                        verbose=verbose)
         
         return people
         
@@ -460,8 +412,7 @@ class TinyPersonFactory(TinyFactory):
                         presence_penalty:float=0.0,
                         attempts:int=10, 
                         post_processing_func=None,
-                        verbose:bool=False,
-                        deep_persona:bool=True) -> list:
+                        verbose:bool=False) -> list:
         people = []
 
         #
@@ -473,20 +424,19 @@ class TinyPersonFactory(TinyFactory):
 
         # this is the function that will be executed in parallel
         def generate_person_wrapper(args):
-            self, i, agent_particularities, temperature, frequency_penalty, presence_penalty, attempts, post_processing_func, deep_persona = args
+            self, i, agent_particularities, temperature, frequency_penalty, presence_penalty, attempts, post_processing_func = args
             person = self.generate_person(agent_particularities=agent_particularities, 
                                         temperature=temperature, 
                                         frequency_penalty=frequency_penalty,
                                         presence_penalty=presence_penalty,
                                         attempts=attempts,
-                                        post_processing_func=post_processing_func,
-                                        deep_persona=deep_persona)
+                                        post_processing_func=post_processing_func)
             return i, person
 
         with concurrent.futures.ThreadPoolExecutor() as executor:
             # we use a list of futures to keep track of the results
             futures = [
-                executor.submit(generate_person_wrapper, (self, i, agent_particularities, temperature, frequency_penalty, presence_penalty, attempts, post_processing_func, deep_persona))
+                executor.submit(generate_person_wrapper, (self, i, agent_particularities, temperature, frequency_penalty, presence_penalty, attempts, post_processing_func))
                 for i in range(number_of_people)
             ]
 
@@ -513,8 +463,7 @@ class TinyPersonFactory(TinyFactory):
                         presence_penalty:float=0.0,
                         attempts:int=10, 
                         post_processing_func=None,
-                        verbose:bool=False,
-                        deep_persona:bool=True) -> list:
+                        verbose:bool=False) -> list:
         """
         Generate the people sequentially, not in parallel. This is a simpler alternative.
         """
@@ -525,8 +474,7 @@ class TinyPersonFactory(TinyFactory):
                           frequency_penalty=frequency_penalty,
                           presence_penalty=presence_penalty,
                           attempts=attempts,
-                          post_processing_func=post_processing_func,
-                          deep_persona=deep_persona)
+                          post_processing_func=post_processing_func)
             if person is not None:
                 people.append(person)
             info_msg = f"Generated person {i+1}/{number_of_people}: {person.minibio()}"
@@ -610,11 +558,6 @@ class TinyPersonFactory(TinyFactory):
             if len(self.remaining_characteristics_sample) != n:
                 logger.warning(f"Expected {n} samples, but got {len(self.remaining_characteristics_sample)} samples. The LLM may have failed to sum up the quantities in the sampling plan correctly.")
 
-            # If we got more samples than requested, we truncate them to avoid generating too many names or personas.
-            if len(self.remaining_characteristics_sample) > n:
-                logger.info(f"Truncating {len(self.remaining_characteristics_sample)} samples to the requested {n} samples.")
-                self.remaining_characteristics_sample = self.remaining_characteristics_sample[:n]
-
             logger.info(f"Sample plan has been flattened, contains {len(self.remaining_characteristics_sample)} total samples.")
             logger.debug(f"Remaining characteristics sample: {json.dumps(self.remaining_characteristics_sample, indent=4)}")
 
@@ -1352,42 +1295,6 @@ class TinyPersonFactory(TinyFactory):
                                                   presence_penalty=presence_penalty,
                                                   response_format={"type": "json_object"})
     
-    def _generate_deep_persona_internal(self, initial_spec: dict) -> dict:
-        """
-        Performs a second API call to enrich the persona with a depth of 350 attributes.
-        """
-        logger.info(f"Enriching persona {initial_spec.get('name')} to deep persona (depth 350)...")
-        
-        prompt = f"""
-        You are an expert persona generator. You have been provided with an initial persona profile:
-        {json.dumps(initial_spec, indent=4)}
-        
-        TASK:
-        Take all the attributes from this initial profile and expand them significantly to reach a depth of 350 attributes/nuances. 
-        The final profile must be incredibly detailed, authentic, and realistic. 
-        Expand on every field: education, occupation, style, personality, preferences, beliefs, skills, behaviors, health, relationships, and other_facts.
-        Provide at least 50 detailed entries for each complex field (preferences, beliefs, other_facts).
-        
-        Rules:
-        - Maintain consistency with the initial profile.
-        - Output ONLY a valid JSON object.
-        - Use the same field structure as the input.
-        """
-        
-        messages = [
-            {"role": "system", "content": "You are a specialized system for creating ultra-deep, 350-attribute persona specifications."},
-            {"role": "user", "content": prompt}
-        ]
-        
-        # Use the Helmholtz client via send_message
-        message = self._aux_model_call(messages=messages, temperature=1.2, frequency_penalty=0.0, presence_penalty=0.0)
-        
-        if message is not None:
-            enriched_spec = utils.extract_json(message["content"])
-            return enriched_spec
-        
-        return initial_spec
-
     @transactional()
     def _setup_agent(self, agent, configuration):
         """

tinytroupe/openai_utils.py

@@ -31,8 +31,6 @@ class OpenAIClient:
     def __init__(self, cache_api_calls=default["cache_api_calls"], cache_file_name=default["cache_file_name"]) -> None:
         logger.debug("Initializing OpenAIClient")
 
-        self.client = None
-
         # should we cache api calls and reuse them?
         self.set_api_cache(cache_api_calls, cache_file_name)
     
@@ -54,8 +52,7 @@ class OpenAIClient:
         """
         Sets up the OpenAI API configurations for this client.
         """
-        if self.client is None:
-            self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
     @config_manager.config_defaults(
         model="model",
@@ -159,33 +156,14 @@ class OpenAIClient:
             chat_api_params["response_format"] = response_format
 
         i = 0
-        while True:
+        while i < max_attempts:
             try:
                 i += 1
 
-                #
-                # Model fallback and retry strategy requested by the user:
-                # 1. alias-fast for 3 attempts, 35s wait
-                # 2. alias-large for 2 attempts, 35s wait
-                # 3. alias-huge until success, 60s wait
-                #
-                # Model fallback strategy using config
-                if i <= 3:
-                    current_model = config["OpenAI"].get("MODEL", "alias-fast")
-                    current_wait_time = 35
-                elif i <= 5:
-                    current_model = config["OpenAI"].get("FALLBACK_MODEL_LARGE", "alias-large")
-                    current_wait_time = 35
-                else:
-                    current_model = config["OpenAI"].get("FALLBACK_MODEL_HUGE", "alias-huge")
-                    current_wait_time = 60
-
-                chat_api_params["model"] = current_model
-
                 try:
-                    logger.debug(f"Sending messages to OpenAI API. Model={current_model}. Token count={self._count_tokens(current_messages, current_model)}.")
+                    logger.debug(f"Sending messages to OpenAI API. Token count={self._count_tokens(current_messages, model)}.")
                 except NotImplementedError:
-                    logger.debug(f"Token count not implemented for model {current_model}.")
+                    logger.debug(f"Token count not implemented for model {model}.")
                     
                 start_time = time.monotonic()
                 logger.debug(f"Calling model with client class {self.__class__.__name__}.")
@@ -193,11 +171,15 @@ class OpenAIClient:
                 ###############################################################
                 # call the model, either from the cache or from the API
                 ###############################################################
-                cache_key = str((current_model, chat_api_params)) # need string to be hashable
+                cache_key = str((model, chat_api_params)) # need string to be hashable
                 if self.cache_api_calls and (cache_key in self.api_cache):
                     response = self.api_cache[cache_key]
                 else:
-                    response = self._raw_model_call(current_model, chat_api_params)
+                    if waiting_time > 0:
+                        logger.info(f"Waiting {waiting_time} seconds before next API request (to avoid throttling)...")
+                        time.sleep(waiting_time)
+                    
+                    response = self._raw_model_call(model, chat_api_params)
                     if self.cache_api_calls:
                         self.api_cache[cache_key] = response
                         self._save_cache()
@@ -213,21 +195,35 @@ class OpenAIClient:
                 else:
                     return utils.sanitize_dict(self._raw_model_response_extractor(response))
 
-            except (InvalidRequestError, openai.BadRequestError) as e:
+            except InvalidRequestError as e:
+                logger.error(f"[{i}] Invalid request error, won't retry: {e}")
+
+                # there's no point in retrying if the request is invalid
+                # so we return None right away
+                return None
+            
+            except openai.BadRequestError as e:
                 logger.error(f"[{i}] Invalid request error, won't retry: {e}")
+                
+                # there's no point in retrying if the request is invalid
+                # so we return None right away
                 return None
             
-            except (openai.RateLimitError,
-                    openai.APITimeoutError,
-                    openai.APIConnectionError,
-                    openai.InternalServerError,
-                    NonTerminalError,
-                    Exception) as e:
-                msg = f"[{i}] {type(e).__name__} Error with {current_model}: {e}. Waiting {current_wait_time} seconds before next attempt..."
-                logger.warning(msg)
-
-                time.sleep(current_wait_time)
-                continue
+            except openai.RateLimitError:
+                logger.warning(
+                    f"[{i}] Rate limit error, waiting a bit and trying again.")
+                aux_exponential_backoff()
+            
+            except NonTerminalError as e:
+                logger.error(f"[{i}] Non-terminal error: {e}")
+                aux_exponential_backoff()
+                
+            except Exception as e:
+                logger.error(f"[{i}] {type(e).__name__} Error: {e}")
+                aux_exponential_backoff()
+
+        logger.error(f"Failed to get response after {max_attempts} attempts.")
+        return None
     
     def _raw_model_call(self, model, chat_api_params):
         """
@@ -250,12 +246,8 @@ class OpenAIClient:
             chat_api_params["reasoning_effort"] = default["reasoning_effort"]
 
 
-        # To make the log cleaner, we remove the messages from the logged parameters,
-        # unless we are in debug mode
-        if logger.getEffectiveLevel() <= logging.DEBUG:
-            logged_params = chat_api_params
-        else:
-            logged_params = {k: v for k, v in chat_api_params.items() if k != "messages"}
+        # To make the log cleaner, we remove the messages from the logged parameters
+        logged_params = {k: v for k, v in chat_api_params.items() if k != "messages"} 
 
         if "response_format" in chat_api_params:
             # to enforce the response format via pydantic, we need to use a different method
@@ -404,23 +396,22 @@ class AzureClient(OpenAIClient):
         Sets up the Azure OpenAI Service API configurations for this client,
         including the API endpoint and key.
         """
-        if self.client is None:
-            if os.getenv("AZURE_OPENAI_KEY"):
-                logger.info("Using Azure OpenAI Service API with key.")
-                self.client = AzureOpenAI(azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
-                                        api_version = config["OpenAI"]["AZURE_API_VERSION"],
-                                        api_key = os.getenv("AZURE_OPENAI_KEY"))
-            else:  # Use Entra ID Auth
-                logger.info("Using Azure OpenAI Service API with Entra ID Auth.")
-                from azure.identity import DefaultAzureCredential, get_bearer_token_provider
-
-                credential = DefaultAzureCredential()
-                token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
-                self.client = AzureOpenAI(
-                    azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
-                    api_version = config["OpenAI"]["AZURE_API_VERSION"],
-                    azure_ad_token_provider=token_provider
-                )
+        if os.getenv("AZURE_OPENAI_KEY"):
+            logger.info("Using Azure OpenAI Service API with key.")
+            self.client = AzureOpenAI(azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
+                                    api_version = config["OpenAI"]["AZURE_API_VERSION"],
+                                    api_key = os.getenv("AZURE_OPENAI_KEY"))
+        else:  # Use Entra ID Auth
+            logger.info("Using Azure OpenAI Service API with Entra ID Auth.")
+            from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+
+            credential = DefaultAzureCredential()
+            token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
+            self.client = AzureOpenAI(
+                azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
+                api_version = config["OpenAI"]["AZURE_API_VERSION"],
+                azure_ad_token_provider=token_provider
+            )
 
 
 class HelmholtzBlabladorClient(OpenAIClient):
@@ -433,17 +424,10 @@ class HelmholtzBlabladorClient(OpenAIClient):
         """
         Sets up the Helmholtz Blablador API configurations for this client.
         """
-        api_key = os.getenv("BLABLADOR_API_KEY")
-        if not api_key:
-            logger.warning("BLABLADOR_API_KEY not found in environment.")
-            api_key = "dummy"
-
-        if self.client is None or self.client.api_key != api_key:
-            logger.debug(f"Setting up Helmholtz client with base_url and key.")
-            self.client = OpenAI(
-                base_url="https://api.helmholtz-blablador.fz-juelich.de/v1",
-                api_key=api_key,
-            )
+        self.client = OpenAI(
+            base_url="https://api.helmholtz-blablador.fz-juelich.de/v1",
+            api_key=os.getenv("BLABLADOR_API_KEY", "dummy"),
+        )
 
 ###########################################################################
 # Exceptions

tinytroupe/utils/llm.py

@@ -721,7 +721,7 @@ class LLMChat:
 
     def _request_list_of_dict_llm_message(self):
             return {"role": "user",
-                    "content": "The `value` field you generate **must** be a list of dictionaries, specified as a JSON structure embedded in a string. For example, `[\\{...\\}, \\{...\\}, ...]`. This is critical for later processing."}
+                    "content": "The `value` field you generate **must** be a list of dictionaries, specified as a JSON structure embedded in a string. For example, `[\{...\}, \{...\}, ...]`. This is critical for later processing."}
 
     def _coerce_to_list(self, llm_output:str):
         """

tinytroupe/utils/semantics.py

@@ -265,45 +265,3 @@ def compute_semantic_proximity(text1: str, text2: str, context: str = None) -> f
     """
     # llm decorator will handle the body of this function
 
-@llm()
-def select_best_persona(criteria: str, personas: list) -> int:
-    """
-    Given a set of criteria and a list of personas (each a dictionary),
-    select the index of the persona that best matches the criteria.
-    If no persona matches at all, return -1.
-
-    Rules:
-    - You must analyze each persona against the criteria.
-    - Return ONLY the integer index (starting from 0) of the best matching persona.
-    - Do not provide any explanation, just the number.
-    - If there are multiple good matches, pick the best one.
-
-    Args:
-        criteria (str): The search criteria or description of the desired persona.
-        personas (list): A list of dictionaries, where each dictionary is a persona specification.
-
-    Returns:
-        int: The index of the best matching persona, or -1 if none match.
-    """
-    # llm decorator will handle the body of this function
-
-@llm()
-def select_relevant_personas_utility(context: str, personas: list) -> list:
-    """
-    Given a context and a list of personas (each a dictionary),
-    select which personas are relevant to the context.
-
-    Rules:
-    - Analyze each persona against the provided context.
-    - Return a LIST of indices (starting from 0) of the relevant personas.
-    - Return an empty list [] if none match.
-    - Provide the result as a JSON array of integers.
-
-    Args:
-        context (str): The context or requirements for persona selection.
-        personas (list): A list of dictionaries, where each dictionary is a persona specification.
-
-    Returns:
-        list: A list of indices of the matching personas.
-    """
-    # llm decorator will handle the body of this function