Upload folder using huggingface_hub

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,80 @@
 ---
-title: Slm Function Calling
-emoji: 🐠
-colorFrom: pink
-colorTo: red
+title: SLM Function Calling
+emoji: "\U0001F697"
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.2.0
+sdk_version: "4.44.0"
 app_file: app.py
-pinned: false
+license: mit
+tags:
+  - function-calling
+  - gpt2
+  - lora
+  - car-control
+  - nlp
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SLM Function Calling - Car Control Demo
+
+Convert natural language commands into structured function calls using a fine-tuned GPT-2 model with LoRA.
+
+## Demo
+
+Try commands like:
+- "Set the temperature to 22 degrees for the driver"
+- "Turn up the heat"
+- "Navigate to Central Park"
+- "Play jazz music at volume 7"
+- "Lock all the doors"
+
+## Model Details
+
+| Property | Value |
+|----------|-------|
+| Base Model | GPT-2 (124M parameters) |
+| Fine-tuning | LoRA (rank=32, alpha=32) |
+| Training Data | ~156K car control command samples |
+| Functions | 18 car control functions |
+| Input | Natural language command |
+| Output | Structured function call JSON |
+
+## Function Categories
+
+The model supports 18 functions across these categories:
+
+- **Climate Control:** set_temperature, adjust_temperature, set_fan_speed, adjust_fan_speed
+- **Comfort:** adjust_seat, control_window
+- **Wipers & Defroster:** set_wiper_speed, adjust_wiper_speed, activate_defroster
+- **Engine & Security:** start_engine, lock_doors
+- **Entertainment:** play_music
+- **Navigation:** set_navigation_destination
+- **Lighting:** toggle_headlights, control_ambient_lighting
+- **Driving:** set_cruise_control, toggle_sport_mode
+- **Maintenance:** check_battery_health
+
+## Output Format
+
+The model generates function calls in this format:
+
+```
+<functioncall> {"name": "function_name", "arguments": "{'param': value}"} <|im_end|>
+```
+
+## Training
+
+The model was trained using:
+- ChatML format with system/user/assistant messages
+- Label masking (loss computed only on assistant response)
+- LoRA adapters targeting attention layers (c_attn, c_proj)
+
+## Limitations
+
+- Only trained on car control domain
+- May produce incorrect outputs for ambiguous or out-of-domain queries
+- Best results with clear, specific commands
+
+## Links
+
+- [GitHub Repository](https://github.com/suyash94/slm-function-calling)
+- [Model Weights on HuggingFace](https://huggingface.co/suyash94/gpt2-fc-adapter)

app.py

@@ -0,0 +1,256 @@
+"""SLM Function Calling - Gradio App for HuggingFace Spaces."""
+
+import os
+
+import gradio as gr
+from inferencer import Inferencer
+
+# Configuration
+REPO_ID = os.environ.get("HF_MODEL_REPO", "suyash94/gpt2-fc-adapter")
+LOCAL_DIR = os.environ.get("LOCAL_CHECKPOINT_DIR", None)
+BASE_MODEL = os.environ.get("BASE_MODEL", "gpt2")
+
+# Initialize inferencer (loads model on startup)
+print("=" * 60)
+print("SLM Function Calling - Car Control Demo")
+print("=" * 60)
+if LOCAL_DIR:
+    print(f"Loading from local: {LOCAL_DIR}")
+    inferencer = Inferencer(local_dir=LOCAL_DIR, base_model=BASE_MODEL)
+else:
+    print(f"Loading from HuggingFace Hub: {REPO_ID}")
+    inferencer = Inferencer(repo_id=REPO_ID, base_model=BASE_MODEL)
+print("Model ready!")
+
+
+def predict_function_call(command: str) -> tuple[str, dict]:
+    """Predict function call from user command.
+
+    :param command: User's natural language command
+    :return: Tuple of (raw response, parsed function call dict)
+    """
+    if not command or not command.strip():
+        return "", {"info": "Please enter a command"}
+
+    result = inferencer.predict(command.strip())
+
+    raw_response = result["response"]
+    parsed = result["parsed"]
+
+    return raw_response, parsed
+
+
+# Example commands covering all 18 functions
+EXAMPLE_COMMANDS = [
+    # Climate Control
+    ["Set the temperature to 22 degrees for the driver"],
+    ["Turn up the heat"],
+    ["Set the fan to high"],
+    # Comfort
+    ["Move my seat forward"],
+    ["Close all the windows"],
+    # Wipers & Defroster
+    ["Set wipers to medium"],
+    ["Speed up the wipers"],
+    ["Turn on the defroster for 15 minutes"],
+    # Engine & Doors
+    ["Start the engine"],
+    ["Lock all the doors"],
+    # Entertainment
+    ["Play some jazz music at volume 7"],
+    # Navigation
+    ["Navigate to Central Park, New York"],
+    # Lighting
+    ["Turn on the headlights"],
+    ["Set ambient lighting to blue at intensity 8"],
+    # Driving
+    ["Set cruise control to 80"],
+    ["Activate sport mode"],
+    # Maintenance
+    ["Check the battery health with history"],
+]
+
+
+# Main description (left column)
+LEFT_DESCRIPTION = """
+# SLM Function Calling
+
+A **small language model (GPT-2, 124M params)** fine-tuned to convert natural language commands into structured function calls for car control.
+
+## What This Model Does
+
+Given a command like *"Set the temperature to 22 degrees"*, outputs:
+
+```json
+{"fn_name": "set_temperature", "properties": {"temperature": 22}}
+```
+
+## Available Functions (18 Total)
+
+| Category | Functions |
+|----------|-----------|
+| **Climate** | `set_temperature`, `adjust_temperature`, `set_fan_speed`, `adjust_fan_speed` |
+| **Comfort** | `adjust_seat`, `control_window` |
+| **Wipers** | `set_wiper_speed`, `adjust_wiper_speed`, `activate_defroster` |
+| **Engine** | `start_engine`, `lock_doors` |
+| **Media** | `play_music` |
+| **Nav** | `set_navigation_destination` |
+| **Lights** | `toggle_headlights`, `control_ambient_lighting` |
+| **Driving** | `set_cruise_control`, `toggle_sport_mode` |
+| **Maintenance** | `check_battery_health` |
+
+## Example Commands
+
+- *"Set the temperature to 25 degrees"*
+- *"Turn up the heat"* / *"Make it cooler"*
+- *"Move my seat forward"*
+- *"Open all windows"*
+- *"Turn on the wipers"*
+- *"Start the car remotely"*
+- *"Lock the doors"*
+- *"Play jazz at volume 7"*
+- *"Navigate to Central Park"*
+- *"Turn on headlights"*
+- *"Set ambient lighting to blue"*
+- *"Set cruise control to 80"*
+- *"Activate sport mode"*
+- *"Check battery health"*
+"""
+
+FUNCTION_REFERENCE = """
+## Function Reference
+
+### Climate Control
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `set_temperature` | Set temperature in a zone | `temperature` (1-80) | `area` (driver/front-passenger/rear-right/rear-left), `unit` (Celsius/Fahrenheit) |
+| `adjust_temperature` | Increase/decrease temperature | `action` (increase/decrease) | `area` |
+| `set_fan_speed` | Set fan to specific level | `speed` (LOW/MEDIUM/HIGH) | `area` |
+| `adjust_fan_speed` | Increase/decrease fan speed | `speed` (increase/decrease) | `area` |
+
+### Comfort
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `adjust_seat` | Adjust seat position | `position` (forward/backward/up/down/tilt-forward/tilt-backward) | `seat_type` (driver/front-passenger/rear_right/rear_left) |
+| `control_window` | Open/close windows | `window_position` (open/close) | `window_location` (driver/front-passenger/rear_right/rear_left) |
+
+### Wipers & Defroster
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `set_wiper_speed` | Set wiper speed | `speed` (LOW/MEDIUM/HIGH) | - |
+| `adjust_wiper_speed` | Increase/decrease wipers | `speed` (INCREASE/DECREASE) | - |
+| `activate_defroster` | Activate window defroster | - | `defroster_zone` (front/rear/all), `duration_minutes` (1-30) |
+
+### Engine & Security
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `start_engine` | Start the car's engine | - | `method` (remote/keyless/keyed) |
+| `lock_doors` | Lock/unlock car doors | `lock_state` (lock/unlock) | - |
+
+### Entertainment
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `play_music` | Control music player | - | `track` (song name), `volume` (1-10) |
+
+### Navigation
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `set_navigation_destination` | Set GPS destination | `destination` (address/location) | - |
+
+### Lighting
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `toggle_headlights` | Turn headlights on/off | `light_state` (on/off) | - |
+| `control_ambient_lighting` | Set interior lighting | `color` (warm/red/blue/dark/white) | `intensity` (1-10) |
+
+### Driving
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `set_cruise_control` | Set cruise control speed | `speed` (10-150 km/h) | - |
+| `toggle_sport_mode` | Activate/deactivate sport mode | `action` (activate/deactivate) | - |
+
+### Maintenance
+
+| Function | Description | Required Parameters | Optional Parameters |
+|----------|-------------|---------------------|---------------------|
+| `check_battery_health` | Check battery status | - | `include_history` (true/false) |
+"""
+
+
+# Build Gradio interface
+with gr.Blocks(
+    title="SLM Function Calling - Car Control",
+) as demo:
+    with gr.Row():
+        # Left column: Description
+        with gr.Column(scale=1):
+            gr.Markdown(LEFT_DESCRIPTION)
+
+        # Right column: Demo
+        with gr.Column(scale=1):
+            gr.Markdown("## Try It Out")
+            command_input = gr.Textbox(
+                label="Your Command",
+                placeholder="e.g., Set the temperature to 22 degrees",
+                lines=2,
+            )
+            predict_btn = gr.Button("Predict Function Call", variant="primary")
+
+            raw_output = gr.Textbox(
+                label="Raw Model Output",
+                lines=3,
+                interactive=False,
+            )
+            parsed_output = gr.JSON(
+                label="Parsed Function Call",
+            )
+
+            gr.Examples(
+                examples=EXAMPLE_COMMANDS,
+                inputs=[command_input],
+                label="Example Commands",
+            )
+
+    # Event handlers
+    predict_btn.click(
+        fn=predict_function_call,
+        inputs=[command_input],
+        outputs=[raw_output, parsed_output],
+    )
+
+    command_input.submit(
+        fn=predict_function_call,
+        inputs=[command_input],
+        outputs=[raw_output, parsed_output],
+    )
+
+    # Function reference accordion
+    gr.Markdown("---")
+
+    with gr.Accordion("Function Reference (All 18 Functions)", open=False):
+        gr.Markdown(FUNCTION_REFERENCE)
+
+    gr.Markdown(
+        """
+---
+**Source Code:** [GitHub Repository](https://github.com/suyash94/slm-function-calling)
+
+**Limitations:**
+- Only trained on car control domain commands
+- May produce incorrect outputs for ambiguous or out-of-domain queries
+- Best results with clear, specific commands
+        """
+    )
+
+
+if __name__ == "__main__":
+    # share=True creates a public URL (works for 72 hours)
+    demo.launch(share=True)

inferencer.py

@@ -0,0 +1,238 @@
+"""Self-contained inference for SLM Function Calling on HuggingFace Spaces."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import torch
+from huggingface_hub import snapshot_download
+from peft import PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedTokenizer
+
+
+# System prompt for function calling
+SYSTEM_PROMPT = (
+    "You are a helpful assistant. You have to either provide a way to answer "
+    "user's request or answer user's query."
+)
+
+
+def parse_function_call(response: str) -> dict[str, Any]:
+    """Parse model output to extract function call.
+
+    Parses the model's response in the format:
+    <functioncall> {"name": "...", "arguments": "..."} <|im_end|>
+
+    :param response: Raw model output string
+    :return: Dict with 'fn_name' and 'properties' keys, or 'error' key if parsing fails
+    """
+    try:
+        # Define delimiters
+        start_delim = "<functioncall> "
+        end_delim = "<|im_end|>"
+
+        # Find the JSON portion between delimiters
+        start_idx = response.find(start_delim)
+        if start_idx == -1:
+            return {"error": "Start delimiter '<functioncall> ' not found"}
+
+        start_idx += len(start_delim)
+        end_idx = response.find(end_delim, start_idx)
+
+        if end_idx == -1:
+            return {"error": "End delimiter '<|im_end|>' not found"}
+
+        # Extract the JSON string
+        json_str = response[start_idx:end_idx].strip()
+
+        # Parse the outer JSON (contains name and arguments)
+        function_call_dict = json.loads(json_str)
+
+        # Extract function name and arguments
+        fn_name = function_call_dict.get("name")
+        if fn_name is None:
+            return {"error": "Function name not found in response"}
+
+        arguments_str = function_call_dict.get("arguments", "{}")
+
+        # Handle arguments - convert Python-style to JSON-style
+        if isinstance(arguments_str, str):
+            # Replace Python boolean/None syntax with JSON syntax
+            arguments_str = arguments_str.replace("'", '"')
+            arguments_str = arguments_str.replace("True", "true")
+            arguments_str = arguments_str.replace("False", "false")
+            arguments_str = arguments_str.replace("None", "null")
+
+            properties = json.loads(arguments_str)
+        elif isinstance(arguments_str, dict):
+            properties = arguments_str
+        else:
+            properties = {}
+
+        return {"fn_name": fn_name, "properties": properties}
+
+    except json.JSONDecodeError as e:
+        return {"error": f"JSON parsing error: {e}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+class Inferencer:
+    """Inference class for SLM Function Calling model.
+
+    Downloads LoRA adapter from HuggingFace Hub on initialization,
+    or loads from a local directory if specified.
+
+    Configuration via environment variables:
+    - HF_MODEL_REPO: HuggingFace Hub repo ID (e.g., 'username/gpt2-fc-adapter')
+    - LOCAL_CHECKPOINT_DIR: Local directory path (overrides HF_MODEL_REPO)
+    - BASE_MODEL: Base model name (default: 'gpt2')
+
+    Example::
+
+        # Set environment variable
+        os.environ["HF_MODEL_REPO"] = "suyash94/gpt2-fc-adapter"
+
+        inferencer = Inferencer()
+        result = inferencer.predict("Set the temperature to 22 degrees")
+        print(result["parsed"])  # {"fn_name": "set_temperature", "properties": {...}}
+    """
+
+    def __init__(
+        self,
+        repo_id: str | None = None,
+        local_dir: str | Path | None = None,
+        base_model: str | None = None,
+        device: torch.device | str | None = None,
+        cache_dir: str | None = None,
+    ) -> None:
+        """Initialize the inferencer.
+
+        :param repo_id: HuggingFace Hub repo ID for LoRA adapter
+        :param local_dir: Local directory containing adapter files
+        :param base_model: Base model name (default: gpt2)
+        :param device: Device for inference (auto-detected if None)
+        :param cache_dir: Cache directory for downloaded files
+        """
+        # Configuration from params or environment
+        self.local_dir = local_dir or os.environ.get("LOCAL_CHECKPOINT_DIR")
+        self.repo_id = repo_id or os.environ.get("HF_MODEL_REPO", "suyash94/gpt2-fc-adapter")
+        self.base_model = base_model or os.environ.get("BASE_MODEL", "gpt2")
+
+        if self.local_dir:
+            self.local_dir = Path(self.local_dir)
+
+        # Set device
+        if device is None:
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        else:
+            self.device = torch.device(device) if isinstance(device, str) else device
+
+        self._model: torch.nn.Module | None = None
+        self._tokenizer: PreTrainedTokenizer | None = None
+
+        # Load model and tokenizer
+        self._load_model(cache_dir)
+
+    def _load_model(self, cache_dir: str | None = None) -> None:
+        """Load base model, tokenizer, and LoRA adapter.
+
+        :param cache_dir: Cache directory for HuggingFace downloads
+        """
+        # Get adapter path (local or download from Hub)
+        if self.local_dir:
+            print(f"Loading adapter from local: {self.local_dir}")
+            adapter_path = self.local_dir
+        else:
+            print(f"Downloading adapter from {self.repo_id}...")
+            adapter_path = Path(
+                snapshot_download(
+                    repo_id=self.repo_id,
+                    cache_dir=cache_dir,
+                )
+            )
+
+        # Load tokenizer from adapter (includes special tokens)
+        print(f"Loading tokenizer from adapter...")
+        self._tokenizer = AutoTokenizer.from_pretrained(
+            adapter_path,
+            trust_remote_code=True,
+        )
+
+        # Ensure pad token is set
+        if self._tokenizer.pad_token is None:
+            self._tokenizer.pad_token = self._tokenizer.eos_token
+
+        # Load base model
+        print(f"Loading base model: {self.base_model}...")
+        base_model = AutoModelForCausalLM.from_pretrained(
+            self.base_model,
+            torch_dtype=torch.float32,  # CPU-friendly
+            trust_remote_code=True,
+        )
+
+        # Resize embeddings if tokenizer has more tokens than model
+        if len(self._tokenizer) > base_model.get_input_embeddings().num_embeddings:
+            print(f"Resizing embeddings: {base_model.get_input_embeddings().num_embeddings} -> {len(self._tokenizer)}")
+            base_model.resize_token_embeddings(len(self._tokenizer))
+
+        # Load LoRA adapter
+        print(f"Loading LoRA adapter...")
+        self._model = PeftModel.from_pretrained(
+            base_model,
+            adapter_path,
+        )
+
+        # Move to device and set eval mode
+        self._model.to(self.device)
+        self._model.eval()
+
+        print(f"Model loaded on device: {self.device}")
+
+    def predict(self, user_query: str, max_new_tokens: int = 128) -> dict[str, Any]:
+        """Generate a function call prediction for a user query.
+
+        :param user_query: User's natural language command
+        :param max_new_tokens: Maximum new tokens to generate
+        :return: Dict with 'response' and 'parsed' (function call info)
+        """
+        if self._model is None or self._tokenizer is None:
+            raise RuntimeError("Model not loaded")
+
+        # Format as chat
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_query},
+        ]
+
+        # Apply chat template
+        input_text = self._tokenizer.apply_chat_template(messages, tokenize=False)
+
+        # Tokenize
+        inputs = self._tokenizer(input_text, return_tensors="pt")
+        inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+        # Generate
+        with torch.no_grad():
+            outputs = self._model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                pad_token_id=self._tokenizer.pad_token_id,
+                eos_token_id=self._tokenizer.eos_token_id,
+                do_sample=False,  # Deterministic
+            )
+
+        # Decode response (only the generated part)
+        full_response = self._tokenizer.decode(outputs[0], skip_special_tokens=False)
+        response = full_response[len(input_text):]
+
+        # Parse function call
+        parsed = parse_function_call(response)
+
+        return {
+            "response": response,
+            "parsed": parsed,
+        }

requirements.txt

@@ -0,0 +1,12 @@
+# Core ML
+torch>=2.1.0
+transformers>=4.46.0
+
+# LoRA adapter loading
+peft>=0.13.0
+
+# Gradio UI
+gradio>=4.0.0
+
+# HuggingFace Hub for model download
+huggingface_hub>=0.20.0