Upload 12 files

README.md

@@ -1,26 +1,24 @@
 ---
-title: veureu-stools
-emoji: 🛠️
-colorFrom: yellow
-colorTo: yellow
+title: veureu-schat
+emoji: 💬
+colorFrom: purple
+colorTo: red
 sdk: gradio
 sdk_version: "4.44.1"
 app_file: app.py
 pinned: false
 ---
 
-# 🛠️ veureu-stools (Salamandra-7B-Tools · ZeroGPU)
+# 💬 veureu-schat (Salamandra-7B-Instruct · ZeroGPU)
 
 ## Endpoints
-- **`/api/predict`** (Gradio): entrada `[ "<messages_json>", "<tools_json>" ]` → salida `{ "text": "...", "tool_calls": [...], "tool_results": [...] }`.  
+- **`/api/predict`** (Gradio): entrada `["<prompt>"]` → salida `"<texto>"`.  
   ➜ Este es el endpoint que usa el Space **engine**.
-- **`/api/chat`** (Gradio): entrada `[ "<messages_json>", "<tools_json>", max_new_tokens, temperature, top_p ]` → salida idéntica.
+- **`/api/generate`** (Gradio): entrada `[prompt, system, max_new_tokens, temperature, top_p]` → salida `"<texto>"`.
 
 ### Variables de entorno
-- `MODEL_ID` (opcional): por defecto `BSC-LT/salamandra-7b-tools`.  
-  Puedes apuntar a `BSC-LT/salamandra-7b-instruct` si prefieres.
+- `MODEL_ID` (opcional): por defecto `BSC-LT/salamandra-7b-instruct`.
 
 ### Notas
-- El modelo **no ejecuta** herramientas reales salvo un **ejemplo local**: `calculator` (seguro).  
-  Si el modelo devuelve `{"tool_calls":[...]}`, el Space intentará ejecutar esas llamadas en sandbox y añadirá `tool_results`.  
-  Puedes desactivar la ejecución poniendo `EXECUTE_TOOLS=False` en `app.py`.
+- El modelo usa `chat_template` si existe; si no, se compone un prompt clásico con bloque `system`.
+- GPU: se activa con `@spaces.GPU` automáticamente (ZeroGPU).

app.py

@@ -103,11 +103,11 @@ with gr.Blocks(title="Salamandra 7B Instruct · ZeroGPU") as demo:
         with gr.Column(scale=1):
             out = gr.Textbox(label="Respuesta", lines=18)
 
-    btn.click(generate_advanced, [in_prompt, in_system, max_new, temp, top_p], out, api_name="generate")
+    btn.click(generate_advanced, [in_prompt, in_system, max_new, temp, top_p], out, api_name="generate", concurrency_limit=1)
 
     # Endpoint minimalista compatible con el ENGINE (/predict: solo prompt)
     in_prompt_engine = gr.Textbox(label="Prompt (ENGINE)", value="Di hola en una frase.")
     out_engine = gr.Textbox(label="Respuesta (ENGINE)")
-    gr.Button("Probar /predict").click(predict_for_engine, [in_prompt_engine], out_engine, api_name="predict")
+    gr.Button("Probar /predict").click(predict_for_engine, [in_prompt_engine], out_engine, api_name="predict", concurrency_limit=1)
 
-demo.queue(concurrency_count=1, max_size=16).launch()
+demo.queue(max_size=16).launch()

engine-ddo/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.sqlite3
+*.db
+*.pyc
+.env
+/data/

engine-ddo/Dockerfile

@@ -0,0 +1,20 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the dependencies file to the working directory
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code to the working directory
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

engine-ddo/README.md

@@ -0,0 +1,21 @@
+---
+title: Engine (Due Diligence Optimization)
+emoji: ⚙️
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+---
+
+# engine-ddo (FastAPI)
+
+
+FastAPI backend for Due Diligence Optimization demo. Persists data in SQLite and exposes REST endpoints for:
+- Products: ingest from PDFs, list, detail
+- Customers: list/update
+- Interactions: chat with persistence (conversations/messages)
+
+
+## Run locally
+```bash
+uvicorn main:app --host 0.0.0.0 --port 7860 --reload

engine-ddo/db.py

@@ -0,0 +1,20 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, DeclarativeBase
+import os
+
+
+DB_PATH = os.environ.get("DDO_DB_PATH", "./ddo.sqlite3")
+engine = create_engine(f"sqlite:///{DB_PATH}", connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+class Base(DeclarativeBase):
+	pass
+
+
+def get_db():
+	db = SessionLocal()
+	try:
+		yield db
+	finally:
+		db.close()

engine-ddo/main.py

@@ -0,0 +1,127 @@
+import os
+from fastapi import FastAPI, UploadFile, File, Depends, HTTPException, Form
+from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy.orm import Session
+from db import Base, engine, get_db
+from models import Product, CustomerProfile
+from schemas import (
+    ProductOut, CustomerOut, CustomerUpdate,
+    ChatRequest, ChatResponse, ConversationOut
+)
+from services import extract_and_upsert_products_from_llm, ensure_default_customers, get_or_create_conversation, add_message, get_history
+from typing import List
+import tempfile
+
+app = FastAPI(title="engine-ddo", openapi_url="/openapi.json")
+
+# CORS for Streamlit UI Space
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize DB
+Base.metadata.create_all(bind=engine)
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+# -------- PRODUCTS --------
+@app.post("/products/ingest", response_model=List[ProductOut])
+async def ingest_products(public_offering: UploadFile = File(...), private_notes: UploadFile = File(...), db: Session = Depends(get_db)):
+    # Save temp files to pass paths to the service
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as f1:
+        f1.write(await public_offering.read())
+        public_path = f1.name
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as f2:
+        f2.write(await private_notes.read())
+        notes_path = f2.name
+
+    try:
+        # Call the new service to process PDFs with an LLM
+        extract_and_upsert_products_from_llm(db, public_path, notes_path)
+    finally:
+        # Clean up the temporary files
+        os.remove(public_path)
+        os.remove(notes_path)
+
+    # Return all products from the database
+    rows = db.query(Product).order_by(Product.name.asc()).all()
+    return rows
+
+@app.get("/products/list", response_model=List[ProductOut])
+def list_products(db: Session = Depends(get_db)):
+    rows = db.query(Product).order_by(Product.name.asc()).all()
+    return rows
+
+# -------- CUSTOMERS --------
+@app.get("/customers/list", response_model=List[CustomerOut])
+def list_customers(db: Session = Depends(get_db)):
+    ensure_default_customers(db)
+    rows = db.query(CustomerProfile).order_by(CustomerProfile.name.asc()).all()
+    return rows
+
+@app.post("/customers/update", response_model=CustomerOut)
+def update_customer(payload: CustomerUpdate, db: Session = Depends(get_db)):
+    row = db.query(CustomerProfile).filter_by(name=payload.name).first()
+    if not row:
+        row = CustomerProfile(name=payload.name)
+        db.add(row)
+    if payload.attributes is not None:
+        row.attributes = payload.attributes
+    if payload.wcltv is not None:
+        row.wcltv = payload.wcltv
+    if payload.n is not None:
+        row.n = payload.n
+    db.commit()
+    db.refresh(row)
+    return row
+
+# -------- INTERACTIONS (chat) --------
+
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+MODEL = os.environ.get("LLM_MODEL", "gpt-4o-mini")
+
+async def llm_reply(system_prompt: str, history: list, user_text: str) -> str:
+    """Return a reply from an external LLM if OPENAI_API_KEY set, else a rule-based stub."""
+    if OPENAI_API_KEY:
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=OPENAI_API_KEY)
+            messages = [{"role": "system", "content": system_prompt}] + history + [{"role": "user", "content": user_text}]
+            resp = client.chat.completions.create(model=MODEL, messages=messages)
+            return resp.choices[0].message.content.strip()
+        except Exception as e:
+            return f"[LLM error fallback] I couldn't reach the model ({e}). Let's continue anyway."
+    # Fallback deterministic reply for demo
+    return "Thanks for the details! Could you share your main need, budget, and timeline? I can match a product for you."
+
+@app.post("/interactions/chat", response_model=ChatResponse)
+async def chat(req: ChatRequest, db: Session = Depends(get_db)):
+    profile = req.profile_name or "random"
+    convo = get_or_create_conversation(db, profile)
+    add_message(db, convo.id, sender="customer", text=req.user_text)
+
+    # Build history for LLM
+    hist = []
+    for turn in get_history(db, convo.id):
+        role = "user" if turn["sender"] == "customer" else "assistant"
+        hist.append({"role": role, "content": turn["text"]})
+
+    system_prompt = (
+        "You are a helpful sales assistant. Keep answers short, ask clarifying questions, and reference products generically."
+    )
+    reply = await llm_reply(system_prompt, hist, req.user_text)
+    add_message(db, convo.id, sender="agent", text=reply)
+
+    return {"reply": reply, "conversation_id": convo.id}
+
+@app.get("/interactions/history", response_model=ConversationOut)
+async def history(profile_name: str, db: Session = Depends(get_db)):
+    convo = get_or_create_conversation(db, profile_name)
+    hist = get_history(db, convo.id)
+    return {"id": convo.id, "profile_name": profile_name, "history": hist}

engine-ddo/models.py

@@ -0,0 +1,40 @@
+from sqlalchemy import Column, Integer, String, Text, Float, ForeignKey, DateTime
+from sqlalchemy.orm import relationship
+from datetime import datetime
+from db import Base
+
+
+class Product(Base):
+	__tablename__ = "products"
+	id = Column(Integer, primary_key=True)
+	name = Column(String(200), unique=True, index=True)
+	description = Column(Text, nullable=True)
+	notes = Column(Text, nullable=True)
+	price = Column(Float, nullable=True)
+
+
+class CustomerProfile(Base):
+	__tablename__ = "customer_profiles"
+	id = Column(Integer, primary_key=True)
+	name = Column(String(200), unique=True, index=True)
+	attributes = Column(Text) # JSON or plain text description
+	wcltv = Column(Float, default=0.0)
+	n = Column(Integer, default=0)
+
+
+class Conversation(Base):
+	__tablename__ = "conversations"
+	id = Column(Integer, primary_key=True)
+	profile_name = Column(String(200), index=True)
+	started_at = Column(DateTime, default=datetime.utcnow)
+	messages = relationship("Message", back_populates="conversation", cascade="all, delete-orphan")
+
+
+class Message(Base):
+	__tablename__ = "messages"
+	id = Column(Integer, primary_key=True)
+	conversation_id = Column(Integer, ForeignKey("conversations.id"))
+	sender = Column(String(32)) # 'customer' or 'agent'
+	text = Column(Text)
+	ts = Column(DateTime, default=datetime.utcnow)
+	conversation = relationship("Conversation", back_populates="messages")

engine-ddo/requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.115.0
+uvicorn==0.30.1
+pydantic==2.8.2
+SQLAlchemy==2.0.31
+python-multipart==0.0.9
+httpx==0.27.0
+PyPDF2==3.0.1
+openai==1.43.0 # optional; used only if OPENAI_API_KEY provided

engine-ddo/schemas.py

@@ -0,0 +1,52 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+
+class ProductOut(BaseModel):
+	id: int
+	name: str
+	description: Optional[str] = None
+	notes: Optional[str] = None
+	price: Optional[float] = None
+
+	class Config:
+		from_attributes = True
+
+
+class CustomerOut(BaseModel):
+	id: int
+	name: str
+	attributes: str
+	wcltv: float
+	n: int
+
+	class Config:
+		from_attributes = True
+
+
+class CustomerUpdate(BaseModel):
+	name: str
+	attributes: Optional[str] = None
+	wcltv: Optional[float] = None
+	n: Optional[int] = None
+
+
+class ChatTurn(BaseModel):
+	sender: str = Field(pattern="^(customer|agent)$")
+	text: str
+
+
+class ConversationOut(BaseModel):
+	id: int
+	profile_name: str
+	history: List[ChatTurn]
+
+
+class ChatRequest(BaseModel):
+	profile_name: str
+	user_text: str
+
+
+class ChatResponse(BaseModel):
+	reply: str
+	conversation_id: int

engine-ddo/services.py

@@ -0,0 +1,131 @@
+import os
+import json
+from sqlalchemy.orm import Session
+from models import Product, CustomerProfile, Conversation, Message
+from typing import List
+from PyPDF2 import PdfReader
+
+# Product services
+
+def _read_pdf_text(file_path: str) -> str:
+    try:
+        reader = PdfReader(file_path)
+        return "\n".join(page.extract_text() or "" for page in reader.pages)
+    except Exception:
+        return ""
+
+def extract_and_upsert_products_from_llm(db: Session, public_pdf_path: str, private_pdf_path: str):
+    """Extracts product info from PDFs using an LLM and saves to DB."""
+    public_text = _read_pdf_text(public_pdf_path)
+    private_text = _read_pdf_text(private_pdf_path)
+
+    if not public_text and not private_text:
+        # Fallback for demo if PDFs are empty or unreadable
+        demo_products = [
+            Product(name="Demo Basic", description="Standard features for small teams.", notes="High churn risk.", price=9.0),
+            Product(name="Demo Pro", description="Advanced features and priority support.", notes="Stable customer base.", price=39.0),
+            Product(name="Demo Enterprise", description="Dedicated support and custom integrations.", notes="Potential for expansion.", price=199.0),
+        ]
+        for p in demo_products:
+            db.merge(p)
+        db.commit()
+        return
+
+    # Use the LLM call logic from main.py
+    from main import llm_reply
+
+    system_prompt = """
+You are an expert data extractor. Your task is to analyze two documents, a public offering and a private notes document, and extract product information.
+
+Respond with a single JSON array of objects. Each object should represent a product and have the following fields:
+- "product": The name of the product.
+- "description": The description from the public offering document.
+- "notes": Internal notes from the private notes document.
+- "price": The price as a numeric value (float), if available.
+
+If you find information that does not belong to a specific product, assign it to a product named "general".
+Ensure your output is a valid JSON array.
+"""
+
+    user_prompt = f"""
+Here is the content from the public offering document:
+--- PUBLIC OFFERING ---
+{public_text}
+
+Here is the content from the private notes document:
+--- PRIVATE NOTES ---
+{private_text}
+
+Please extract the product information as a JSON array.
+"""
+
+    # This is a blocking call, so we don't need async here
+    import asyncio
+    llm_response = asyncio.run(llm_reply(system_prompt, [], user_prompt))
+
+    try:
+        # Clean the response to get only the JSON part
+        json_str = llm_response[llm_response.find('['):llm_response.rfind(']')+1]
+        extracted_data = json.loads(json_str)
+
+        for item in extracted_data:
+            product = Product(
+                name=item.get("product", "general"),
+                description=item.get("description"),
+                notes=item.get("notes"),
+                price=float(item["price"]) if item.get("price") else None
+            )
+            # Use merge to insert or update based on the primary key (name)
+            db.merge(product)
+        db.commit()
+
+    except (json.JSONDecodeError, TypeError, KeyError) as e:
+        # Handle cases where LLM output is not as expected
+        # For demo, we can log the error and maybe insert a placeholder
+        print(f"Error parsing LLM response: {e}")
+        placeholder = Product(name="Parsing Error", description="Could not parse data from documents.", notes=str(llm_response))
+        db.merge(placeholder)
+        db.commit()
+
+# Customer services
+
+def ensure_default_customers(db: Session):
+    defaults = [
+        ("random", "Synthetic profile with randomized traits", 0.0, 0),
+        ("SMB buyer", "Budget-conscious, quick decisions", 1200.0, 85),
+        ("Enterprise buyer", "Long sales cycle, security-focused", 24000.0, 12),
+    ]
+    for name, attrs, w, n in defaults:
+        row = db.query(CustomerProfile).filter_by(name=name).first()
+        if not row:
+            db.add(CustomerProfile(name=name, attributes=attrs, wcltv=w, n=n))
+    db.commit()
+
+# Chat services
+
+def get_or_create_conversation(db: Session, profile_name: str) -> Conversation:
+    convo = (
+        db.query(Conversation)
+        .filter_by(profile_name=profile_name)
+        .order_by(Conversation.id.desc())
+        .first()
+    )
+    if not convo:
+        convo = Conversation(profile_name=profile_name)
+        db.add(convo)
+        db.commit()
+        db.refresh(convo)
+    return convo
+
+
+def add_message(db: Session, conversation_id: int, sender: str, text: str):
+    msg = Message(conversation_id=conversation_id, sender=sender, text=text)
+    db.add(msg)
+    db.commit()
+
+
+def get_history(db: Session, conversation_id: int):
+    convo = db.query(Conversation).filter_by(id=conversation_id).first()
+    if not convo:
+        return []
+    return [{"sender": m.sender, "text": m.text} for m in convo.messages]

requirements.txt

@@ -1,5 +1,3 @@
-gradio>=4.44.1
-spaces>=0.25.0
 transformers>=4.44.0
 torch>=2.2
 accelerate>=0.30.0