Upload 8 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+static/new.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,20 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+*llama.cpp/
+
+# Virtual environments
+.venv
+
+.env
+*.env
+.env.local
+__pycache__/
+*.pyc
+.venv/
+venv/
+.uv/

app.py

@@ -0,0 +1,388 @@
+#بسم الله الرحمن الرحيم
+import gradio as gr
+import asyncio
+import base64
+from client import run_fistal
+import asyncio
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+REQUIRED_SECRETS = [
+    "GOOGLE_API_KEY_1",
+    "GOOGLE_API_KEY_2", 
+    "GOOGLE_API_KEY_3",
+    "GROQ_API_KEY",
+    "GEMINI_API_KEY",
+    "HUGGINGFACE_API_KEY",
+    "MODAL_TOKEN_ID",
+    "MODAL_TOKEN_SECRET"
+]
+
+missing = [s for s in REQUIRED_SECRETS if not os.getenv(s)]
+if missing:
+    raise ValueError(f"Missing secrets in HF Space: {', '.join(missing)}\nAdd them in Settings → Variables and secrets")
+
+    
+
+def image_to_base64(filepath):
+    try:
+        with open(filepath, "rb") as image_file:
+            encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
+            mime_type = "image/jpeg" if filepath.lower().endswith((".jpg", ".jpeg")) else "image/png"
+            return f"data:{mime_type};base64,{encoded_string}"
+    except FileNotFoundError:
+        print(f"Error: Image file not found at {filepath}")
+        return ""
+
+
+image_data_url = image_to_base64("static/new.jpg") 
+full_img = image_to_base64("static/fullnew.jpg")
+
+def app():
+    css = f"""
+    /* Global App Styling */
+    .gradio-container {{
+        background: url('{full_img}') !important;
+        background-size: cover !important;
+        box-shadow: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;!important;
+        outline: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important; !important;
+    }}
+    .gradio-container .block {{
+    background-color: #27272a !important;
+    }}
+    .gradio-container .wrap {{
+    background-color: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;
+    border: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;
+    border-width: 1px !important;
+
+    }}
+    .gradio-container .block,
+.gradio-container .wrap {{
+    border: none !important;
+    box-shadow: none !important;   /* removes shadow */
+    outline: none !important;      /* removes focus outline */
+}}
+    
+    #tuner {{
+        background: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;
+        padding: 10px; 
+        border-radius: 8px; 
+    }}
+    #tuner .wrap {{
+        background-color: #5f5f5f !important;
+    }}
+    .laun {{
+        background: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;
+        padding: 10px; 
+        border-radius: 8px;
+        color: white;
+    }}
+    
+    .mark {{
+        background-color: #27272a !important;
+        padding: 6px;
+    }}
+    .me {{
+        background-color: #27272a !important;
+        color: white !important;
+        border: none !important;
+    }}
+    .me textarea {{
+        background-color: #5f5f5f !important;
+        color: white !important;
+    }}
+    .label, .form > div > label, .block > label {{
+        color: white !important;
+    }}
+    .drop {{
+        background-color: #27272a !important;
+        color: white !important;
+    }}
+    
+    .drop li {{
+        background-color: #27272a !important;
+        color: white !important;
+    }}
+    .drop input {{
+        background-color: #5f5f5f !important;
+        background-size: cover !important;
+        color: white !important;
+        border: none !important;
+        padding: 6px 10px !important;
+        border-radius: 4px !important;
+    }}
+    .drop .wrap {{
+        background-color: #5f5f5f !important;
+        border-radius: 4px !important;
+    }}
+
+    .out {{
+    padding: 10px !important;
+    font-size: 25px !important;
+    /*margin-left: 10px !important;*/
+
+    }}
+
+    .login-container .wrap {{
+        background-color: green !important;
+        border-radius: 20px !important;
+    }}
+    .login-container {{
+        background-color: #5f5f5f !important;
+        display: flex;
+        height: 85vh;
+        width: 100%;
+        margin: 0;
+        padding: 0;
+    }}
+    .left-side {{
+        flex: 1;
+        background: linear-gradient(rgba(0, 0, 0, 0.4), rgba(0, 0, 0, 0.4)), 
+                    url('{image_to_base64("static/new.jpg")}') center/cover;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        color: white;
+        padding: 60px;
+    }}
+    .left-side h1 {{
+        font-size: 3.2rem;
+        font-weight: 700;
+        margin-bottom: 20px;
+        text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
+    }}
+    .left-side p {{
+        font-size: 1.5rem;
+        font-weight: 300;
+        text-align: center;
+        max-width: 500px;
+        text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.5);
+    }}
+    .right-side {{
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        background-image: linear-gradient(to bottom, #000000, #050505, #0b0b0b, #0f0f0f, #131313);
+        padding: 60px;
+    }}
+    .login-box {{
+        background: rgba(255, 255, 255, 0.15);
+        backdrop-filter: blur(10px);
+        border-radius: 20px;
+        padding: 50px 40px;
+        width: 100%;
+        max-width: 400px;
+        box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+        color: white;
+    }}
+    .login-box h2 {{
+        font-size: 2rem;
+        margin-bottom: 30px;
+        text-align: center;
+        margin-left: -50px;
+    }}
+    #launch_button {{
+    width: 100% !important;
+}}
+:root, .gradio-container * {{
+    --block-background-fill: #27272a !important;
+    --panel-background-fill: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;
+    --input-background-fill: #5f5f5f !important;
+    --color-background-primary: #27272a !important;
+    --block-border-width: 1px !important;
+    --block-border-color: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;
+    --panel-border-width: 1px !important;
+    --panel-border-color: linear-gradient(to right, #008DDA, #6A1AAB, #C71585, #F56C40) !important;
+    --neutral-50: #27272a !important;
+}}
+    @media (max-width: 768px) {{
+        .login-container {{
+            flex-direction: column;
+        }}
+        .left-side {{
+            min-height: 40vh;
+        }}
+        .left-side h1 {{
+            font-size: 2.5rem;
+        }}
+    }}
+    """
+
+    with gr.Blocks(title="Fistal AI 🚀", css=css, theme=gr.themes.Ocean()) as demo:
+
+        with gr.Group(visible=True) as login_block:
+            gr.HTML(f"""
+            <div class="login-container">
+                <div class="left-side">
+                    <h1 style="color: white !important;">Fistal AI</h1>
+                    <p style="color: white !important;">Finetune LLM's with ease</p>
+                </div>
+                <div class="right-side">
+                    <div class="login-box">
+                        <h2 style="color: white !important;">✨ Features</h2>
+                        <div style="text-align: left; color: #fff; line-height: 1.8;">
+                            <div style="margin-bottom: 20px;">
+                                <strong style="color: #667eea;">🤖 Agentic AI</strong><br>
+                                <span style="font-size: 0.9rem;color: white !important;">LangGraph-powered automation via Fistal MCP</span>
+                            </div>
+                            <div style="margin-bottom: 20px;">
+                                <strong style="color: #667eea;">⚡ Modal GPU</strong><br>
+                                <span style="font-size: 0.9rem;color: white !important;">Serverless T4 training, no setup needed</span>
+                            </div>
+                            <div style="margin-bottom: 20px;">
+                                <strong style="color: #667eea;">🦥 Unsloth</strong><br>
+                                <span style="font-size: 0.9rem;color: white !important;">2x faster, 70% less memory</span>
+                            </div>
+                            <div style="margin-bottom: 25px;">
+                                <strong style="color: #667eea;">📊 Auto Evaluation</strong><br>
+                                <span style="font-size: 0.9rem;color: white !important;">LLM-as-a-judge with BLEU, ROUGE metrics assessment</span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            """)
+
+            launch_btn = gr.Button(
+                value="🚀 Launch Fistal",
+                elem_id="launch_fistal_btn",
+                elem_classes="laun"
+            )
+
+        # ---------------- MAIN APP BLOCK ----------------
+        with gr.Group(visible=False) as main_block:
+            gr.HTML(f"""
+                <div class="start" style="
+                            background: url('{image_data_url}');
+                            background-size: cover;
+                            background-position: center; 
+                            background-repeat: no-repeat;
+                            padding: 20px;
+                            margin-top:10px;
+                            margin-bottom: 10px;
+                            border-radius: 10px;">
+                    <h1 style="color: white; font-size: 35px;">Fistal AI 🚀</h1>
+                    <p style="color: white; margin-top: -5px;">Seamlessly fine-tune LLMs with an Agentic AI powered by MCP, Modal, and Unsloth.</p>
+                    <div style="display:flex; gap:5px; flex-wrap:wrap; align-items:center; margin-bottom:15px;">
+                        <a href="https://huggingface.co/spaces/your-username/fistal-ai">
+                            <img src="https://img.shields.io/badge/%F0%9F%A4%97%20-%20HF%20Space%20-%20orange" alt="HF Space">
+                        </a>
+                        <img src="https://img.shields.io/badge/Python-3.11-blue?logo=python" alt="Python">
+                        <img src="https://img.shields.io/badge/Modal-Enabled-green" alt="Modal">
+                        <img src="https://img.shields.io/badge/Unsloth-4bit-purple" alt="Unsloth">
+                        <img src="https://img.shields.io/badge/MCP-Enabled-pink" alt="MCP">
+                        <img src="https://img.shields.io/badge/%F0%9F%94%B6%20-%20Gradio%20-%20%23fc7280" alt="Gradio">
+                        <img src="https://img.shields.io/badge/%F0%9F%A4%96%20-%20Agentic%20AI%20-%20%23472731" alt="Agentic AI">
+                        <img src="https://img.shields.io/badge/%F0%9F%A7%AE%20-%201B%2F2B%2F3B%20models%20-%20teal" alt="1B-3B Models">
+                        <img src="https://img.shields.io/badge/%F0%9F%93%9D%20-%20Evaluation%20Report%20-%20purple" alt="Evaluation Report">
+                    </div>
+                </div>
+            """)
+
+            with gr.Group(elem_classes="me"):
+                with gr.Row():
+                    topic = gr.Textbox(label="📚 Dataset topic", placeholder="Python Questions, Return policy FAQS...", elem_classes="me")
+                    samples = gr.Slider(label="📊 Number of samples", minimum=0, maximum=2000, interactive=True, step=5, value=1000, elem_classes="me")
+                    task_type = gr.Dropdown(label="🎯 Task Type", choices=["text-generation","summarization","classification","question-answering"], interactive=True, elem_classes="drop")
+                    model_name = gr.Dropdown(
+                        label="🤖 Model to Fine-tune",
+                        choices=[
+                            "unsloth/Llama-3.2-1B-Instruct-bnb-4bit",
+                            "unsloth/Phi-3-mini-4k-instruct",
+                            "unsloth/Phi-3-medium-4k-instruct",
+                            "unsloth/Llama-3.2-3B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-3B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-1.5B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-0.5B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-Coder-3B-Instruct-bnb-4bit",
+                            "unsloth/gemma-2-2b-it-bnb-4bit",
+                            "unsloth/SmolLM2-1.7B-Instruct-bnb-4bit",
+                            "unsloth/Phi-3.5-mini-instruct-bnb-4bit",
+                            "unsloth/Granite-3.0-2b-instruct-bnb-4bit",
+                            "unsloth/granite-4.0-h-1b-bnb-4bit"
+                        ], interactive=True, elem_classes="drop"
+                    )
+                tuner = gr.Button("🚀 Start Finetuning", size="lg", elem_id="tuner")
+                gr.Markdown("""## <span style="color: white;">🔀 Agent Activity Flow</span>""", elem_classes="mark")
+                status = gr.Textbox(label="Status", value="Ready to start...", interactive=False)
+                output = gr.Markdown(label="Output Log:", value="",  elem_classes="out")
+                model_link = gr.Button(
+    value="🤗 View Model on Hugging Face", 
+    visible=False,  
+    elem_classes="out"
+)
+                async def run_workflow(dataset_topic, samples, model, task, request = gr.Request):
+                    output_log = "## Under the Hood" + "\n\n"
+                    output_log += "📋 **Configuration:**\n\n"
+                    output_log += f"  • Topic: {dataset_topic}\n\n"
+                    output_log += f"  • Samples: {samples}\n\n"
+                    output_log += f"  • Model: {model}\n\n"
+                    output_log += f"  • Task: {task}\n\n"
+
+                    yield (" Starting workflow...", output_log, "")
+
+                    try:
+                        in_eval_report = False
+                        eval_report_buffer = ""
+
+                        async for chunk in run_fistal(
+                            dataset_topic=dataset_topic,
+                            num_samples=samples,
+                            model_name=model,
+                            task_type=task
+                        ):
+                            if "evaluating" in str(chunk).lower() or "llm_as_judge" in str(chunk).lower():
+                                in_eval_report = True
+                            
+                            if in_eval_report:
+                                eval_report_buffer += str(chunk)
+                            else:
+                                output_log += str(chunk)
+
+                            import re
+                            urls = re.findall(r'https://huggingface\.co/[^\s\)]+', output_log + eval_report_buffer)
+                            model_url = urls[0] if urls else ""
+                            model_url = model_url.rstrip('.') 
+                            model_url = re.sub(r'[^a-zA-Z0-9:/._-].*$', '', model_url)
+
+                            yield ("🟡 Processing...", output_log + eval_report_buffer, model_url)
+                            await asyncio.sleep(0.1)
+
+                        # Final output
+                        final_output = output_log
+                        if eval_report_buffer:
+                            final_output += "📊 **EVALUATION REPORT**\n\n"
+                            final_output += eval_report_buffer
+
+                        final_output += "\n\n✨ **Fistal AI has completed the process!**"
+                        yield ("🟢 Complete!", final_output, gr.Button(
+                value="🤗 View Model on Hugging Face", 
+                visible=True, 
+                interactive=True,
+                link=model_url
+            ))
+
+                    except Exception as e:
+                        import traceback
+                        error_log = output_log + f"\n\n❌ **ERROR:**\n```\n{str(e)}\n{traceback.format_exc()}\n```"
+                        yield ("🔴 Error", error_log, "")
+
+                
+                tuner.click(run_workflow, [topic, samples, model_name, task_type], [status, output, model_link])
+
+
+        launch_btn.click(
+            lambda: (gr.update(visible=False), gr.update(visible=True)),
+            None,
+            [login_block, main_block]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    app().launch()

client.py

@@ -0,0 +1,273 @@
+from langgraph.graph import StateGraph, START
+from dotenv import load_dotenv
+from langchain_google_genai import ChatGoogleGenerativeAI
+from typing import TypedDict, Annotated
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+import asyncio
+from langchain_mcp_adapters.client import MultiServerMCPClient
+import os
+from typing import Optional
+import sys
+
+load_dotenv()
+
+api_key = os.getenv("GEMINI_API_KEY")
+
+llm = ChatGoogleGenerativeAI(
+    model="gemini-2.5-flash",
+    temperature=0.2,
+    google_api_key=api_key
+)
+
+client = MultiServerMCPClient(
+    {
+        "FistalMCP": {
+            "transport": "stdio",
+            "command": sys.executable,
+            "args": ["-u", os.path.join(os.path.dirname(__file__), "server.py")]
+        }
+    }
+)
+
+if client:
+    print("✓ Client initialized!")
+else:
+    print("✗ Failed to initialize MCP Client")
+
+
+class ChatState(TypedDict):
+    messages: Annotated[list[BaseMessage], add_messages]
+    dataset_topic: str
+    num_samples: int
+    model_name: str
+    task_type: str
+    dataset_path: Optional[str]
+    converted_path: Optional[str]
+    model_path: Optional[str]
+    hf_url: Optional[str]
+
+
+async def my_graph():
+    """Agent graph that handles mcp tools"""
+    tools = await client.get_tools()
+
+    available_tools = []
+    tool_order = ["generate_json_data", "format_json", "finetune_model", "llm_as_judge"]
+    available_tools = []
+    for tool_name in tool_order:
+        for tool in tools:
+            if tool.name == tool_name:
+                available_tools.append(tool)
+                break
+
+    llm_toolkit = llm.bind_tools(available_tools)
+
+    async def chat_node(state: ChatState):
+        messages = state["messages"]
+        dataset_topic = state['dataset_topic']
+        if isinstance(dataset_topic, list):
+            dataset_topic = dataset_topic[0] if dataset_topic else "unknown"
+        
+        num_samples = state['num_samples']
+        if isinstance(num_samples, list):
+            num_samples = num_samples[0] if num_samples else 100
+        
+        model_name = state['model_name']
+        if isinstance(model_name, list):
+            model_name = model_name[0] if model_name else "unknown"
+        
+        task_type = state['task_type']
+        if isinstance(task_type, list):
+            task_type = task_type[0] if task_type else "text-generation"
+        
+        system_msg = f"""You are Fistal, an AI fine-tuning assistant.
+
+**User's Configuration:**
+- Dataset Topic: {dataset_topic}
+- Number of Samples: {num_samples}
+- Model to Fine-tune: {model_name}
+- Task Type: {task_type}
+- Evaluation : Using LLM
+
+**Your Workflow:**
+1. Use generate_json_data with topic="{dataset_topic}", task_type="{task_type}", num_samples={num_samples}
+   - This returns a dictionary with a "data" field containing the raw dataset
+   
+2. Use format_json with the "data" field from step 1
+   - Pass: raw_data=<the data list from step 1>
+   - This returns a dictionary with a "data" field containing formatted data
+   
+3. Use finetune_model with the "data" field from step 2 and model_name="{model_name}"
+   - Pass: formatted_data=<the data list from step 2>, model_name="{model_name}"
+   - This returns the Hugging Face repo URL
+   
+4. Use llm_as_judge with the repo_id from step 3
+   - Pass: repo_id=<the HF repo from step 3>, topic="{dataset_topic}", task_type="{task_type}"
+
+**FINAL STEP - CRITICAL:**
+5. After completing all tools, you MUST return:
+   - The Hugging Face model URL from step 3
+   - The evaluation report from step 4
+   - Format your final response as:
+   
+🎉 **Fine-tuning Complete!**
+
+**🤗 Model Repository:** [HF Repo Link] \n\n
+**📊 Evaluation Report:** [Full report from llm_as_judge]
+
+**IMPORTANT:**
+- Tools pass DATA directly, not file paths
+- Always mention the tool you are going to use first and then proceed with the tool action
+- Extract the "data" field from each tool's response and pass it to the next tool
+- After llm_as_judge completes, return both the HF URL and evaluation report
+- Keep the user informed of progress at each step
+- If a step takes time, do not stay idle. Inform users about short interesting facts
+- Report any errors clearly
+- Do not mention internal data structures or file paths"""
+
+    
+        full_messages = [SystemMessage(content=system_msg)] + messages
+        response = await llm_toolkit.ainvoke(full_messages)
+        return {'messages': [response]}
+    
+    tool_node = ToolNode(available_tools)
+
+    graph = StateGraph(ChatState)
+
+    graph.add_node("chat_node", chat_node)
+    graph.add_node("tools", tool_node)
+
+    graph.add_edge(START, "chat_node")
+    graph.add_conditional_edges("chat_node", tools_condition)
+    graph.add_edge("tools", "chat_node")
+
+    chat = graph.compile()
+
+    return chat
+
+
+
+
+async def run_fistal(
+    dataset_topic: str,
+    num_samples: int,
+    model_name: str,
+    task_type: str
+):
+    chatbot = await my_graph()
+    user_message = f"""Execute the complete fine-tuning workflow:
+- Generate {num_samples} training examples about {dataset_topic}
+- Fine-tune {model_name}
+- Evaluate for {task_type} task
+
+Start now!"""
+    initial_state = {
+        "messages": [HumanMessage(content=user_message)],
+        "dataset_topic": dataset_topic,
+        "num_samples": num_samples,
+        "model_name": model_name,
+        "task_type": task_type,
+        "dataset_path": None,
+        "converted_path": None,
+        "model_path": None,
+        "hf_url": None
+    }
+    facts = {
+        "generate_json_data": [
+            "💡 Using parallel batch generation with multiple API keys for 3x speed!",
+            "📊 Quality over quantity - diverse examples lead to better models!",
+            "🎯 Generating diverse prompt-response pairs...",
+        ],
+        "format_json": [
+            "🔄 Converting to chat format optimized for instruction tuning...",
+            "💬 Proper formatting helps models understand conversation structure!",
+            "🎨 Applying ChatML format for consistency...",
+            "✅ Validating JSON structure for training compatibility...",
+            "🔧 Optimizing token distribution across examples..."
+        ],
+        "finetune_model": [
+            "🏋️ Training on Modal's serverless T4 GPU...",
+            "💡 Using 4-bit quantization to fit in 16GB VRAM!",
+            "🦥 Unsloth makes training 2x faster with 70% less memory!",
+            "⚡ LoRA fine-tuning updates only 0.1% of model parameters!",
+            "🎯 Typical training time: 10-20 minutes for 500 samples...",
+            "🔥 Your model is learning patterns from authentic data!",
+            "☁️ Uploading to HuggingFace - your model will be public soon!"
+        ],
+        "llm_as_judge": [
+            "📊 Generating evaluation test cases...",
+            "🤖 LLM-as-judge provides qualitative insights!",
+            "✨ Testing model coherence, relevance, and accuracy...",
+            "📝 Creating comprehensive evaluation report...",
+            "🔍 Analyzing response quality and task alignment...",
+            "📝 Creating comprehensive evaluation report...",
+            "📈 Comparing outputs against expected responses...",
+            "🎯 Assessing model's understanding of the domain...",
+            "✅ Finalizing evaluation metrics.."
+        ]
+    }
+
+    current_tool = None
+    fact_i = 0
+
+    async for event in chatbot.astream(initial_state):
+        if "tools" in event:
+            messages = event["tools"].get("messages", [])
+            for msg in messages:
+                if hasattr(msg,"name"):
+                    tool_name = msg.name
+                    current_tool = tool_name
+                    fact_i = 0
+                    yield f"\n{'-'*60}\n"
+                    yield f"🔄 **Using: {tool_name}**\n\n"
+                    if tool_name in facts:
+                        yield f"{facts[tool_name][0]}\n"
+                        await asyncio.sleep(0.3)
+
+        if "chat_node" in event:
+            messages = event["chat_node"].get("messages", [])
+            for msg in messages:
+                if hasattr(msg, 'content') and msg.content:
+                    raw_content = msg.content
+                    content = ""
+                    
+                    if isinstance(raw_content, list):
+                        for item in raw_content:
+                            if isinstance(item, dict) and item.get('type') == 'text':
+                                content += item.get('text', '')
+                        content = content.strip()
+                    elif isinstance(raw_content, str):
+                        content = raw_content
+                    else:
+                        content = str(raw_content)
+                    
+                    if content and len(content) > 20 and "tool_calls" not in content.lower():
+                        yield f"\n🤖 **Fistal:** {content}\n"
+                    
+                    if current_tool and current_tool in facts:
+                        fact_i += 1
+                        if fact_i < len(facts[current_tool]):
+                            yield f"\n💡 {facts[current_tool][fact_i]}\n"
+                            await asyncio.sleep(0.3)
+    yield "✅ **Successfully finetuned!**\n"
+
+
+
+async def main():
+    """Test the agent. Only for running client.py"""
+    print("Testing Fistal Agent\n")
+    
+    result = await run_fistal(
+        "python programming",
+        5,
+        "unsloth/Llama-3.2-1B-Instruct-bnb-4bit",
+        "text-generation"
+    )
+    
+    print(f"\nAgent Response:\n{result}")
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

modal_tool.py

@@ -0,0 +1,259 @@
+import modal
+import json 
+from datasets import Dataset
+import time
+
+
+modal.enable_output()
+
+app = modal.App("fistalfinetuner")
+
+volume = modal.Volume.from_name("fistal-models", create_if_missing=True )
+
+
+
+
+
+modal_image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .apt_install("git")
+    .pip_install(
+        "torch>=2.6.0",
+        "torchvision",
+        "torchaudio",
+        extra_index_url="https://download.pytorch.org/whl/cu121",
+        
+    )
+    .pip_install(
+        "transformers",
+        "datasets",
+        "accelerate",
+        "trl",
+        "bitsandbytes",
+        "peft",
+        "unsloth_zoo",
+        "datasets==4.3.0"
+    )
+    .pip_install(
+        "unsloth @ git+https://github.com/unslothai/unsloth.git"
+    )
+)
+
+@app.function(
+    image=modal_image, 
+    gpu="T4", 
+    timeout=3600,
+    volumes={"/models":volume},
+    retries=modal.Retries(max_retries=0, backoff_coefficient=1.0)
+)
+def train_with_modal(ft_data: str, model_name: str):
+    """
+    Finetuning model using Modal's GPU
+    """
+    import torch
+    
+    if not torch.cuda.is_available():
+        return {"status": "error", "message": "No GPU available!"}
+    
+    from unsloth import FastLanguageModel, is_bf16_supported
+    from transformers import TrainingArguments
+    from trl import SFTTrainer
+    import os
+
+    data = []
+    for line in ft_data.strip().split('\n'):
+        if line.strip():
+            data.append(json.loads(line))
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_name,
+        max_seq_length=512,
+        load_in_4bit=True,
+        dtype=None
+    )
+
+    print("Configuring LoRA...")
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=128,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+        lora_alpha=16,
+        lora_dropout=0,
+        bias="none",
+        random_state=2001,
+        use_gradient_checkpointing="unsloth",
+        loftq_config=None,
+        use_rslora=False
+    )
+    
+    def format_example(example):
+        text = tokenizer.apply_chat_template(
+            example['messages'],
+            tokenize=False,
+            add_generation_prompt=False
+        )
+        return {"text": text}
+    
+    dataset = Dataset.from_list(data)
+    dataset = dataset.map(format_example)
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=dataset,
+        dataset_text_field="text",
+        max_seq_length=2000,
+        dataset_num_proc=2,
+        args=TrainingArguments(
+            per_device_train_batch_size=2,
+            gradient_accumulation_steps=8,
+            warmup_steps=5,
+            num_train_epochs=1,
+            max_steps=30,
+            learning_rate=2e-4,
+            fp16=not is_bf16_supported(),
+            bf16=is_bf16_supported(),
+            logging_steps=1,
+            optim="adamw_8bit",
+            lr_scheduler_type="linear",
+            output_dir="/tmp/training_output",
+            seed=42,
+            report_to="none",
+            dataloader_num_workers=0
+        )
+    )
+    print("Training started...")
+    trainer.train()
+    print("Training complete!")
+
+    timestamp = int(time.time())
+    volume_path = f"/models/finetuned-{timestamp}"
+
+    os.makedirs(volume_path, exist_ok=True)
+    print(f"Saving to: {volume_path}")
+    
+
+    model.save_pretrained_merged(volume_path, tokenizer, save_method="merged_16bit")
+    print("Model saved!")
+    model.config.save_pretrained(volume_path)
+
+    trainer.save_model(volume_path)
+    tokenizer.save_pretrained(volume_path)
+
+
+
+
+
+    volume.commit()
+    print("Volume has been committed!")
+
+    del model
+    del trainer
+    import gc
+    gc.collect()
+    torch.cuda.empty_cache()
+    
+    return {
+        "status":"success",
+        "volume_path":volume_path,
+        "timestamp": timestamp
+
+    }
+
+
+
+
+@app.function(
+    image=modal_image,
+    volumes={"/models": volume},
+    timeout=900,  
+    secrets=[modal.Secret.from_name("huggingface-secret")]
+)
+def upload_to_hf_from_volume(volume_path: str, timestamp: int, repoName: str):
+    """
+    Upload model directly from Modal Volume to HuggingFace
+    This runs on Modal's fast network - no download to local machine needed!
+    """
+    from huggingface_hub import HfApi, create_repo
+    import os
+    
+    print(f"📤 Uploading from {volume_path} to HuggingFace...")
+    
+    if not os.path.exists(volume_path):
+        raise FileNotFoundError(f"Model not found at: {volume_path}")
+    
+    hf_token = os.environ.get("HF_TOKEN")
+    if not hf_token:
+        raise ValueError("HF_TOKEN not found in Modal secrets")
+    
+    hf_api = HfApi()
+    repo_id = f"mahreenfathima/finetuned-{repoName}-{timestamp}"
+    
+    print(f"Creating HuggingFace repo: {repo_id}")
+    create_repo(
+        repo_id=repo_id,
+        token=hf_token,
+        private=False,
+        exist_ok=True,
+        repo_type="model"
+    )
+    
+    print(f"Uploading files to {repo_id}...")
+    hf_api.upload_folder(
+        folder_path=volume_path,
+        repo_id=repo_id,
+        token=hf_token,
+        commit_message=f"Fine-tuned model (timestamp: {timestamp})"
+    )
+    
+    model_url = f"https://huggingface.co/{repo_id}"
+    print(f"✅ Successfully uploaded to {model_url}")
+    
+    return {
+        "model_url": model_url,
+        "repo_id": repo_id
+    }
+
+@app.function(
+    gpu="T4",
+    timeout=600,
+    image=modal_image
+)
+def evaluate_model(repo_id: str, test_inputs: list[str]):
+    """Load model and run inference on test cases"""
+    from unsloth import FastLanguageModel
+    from transformers import AutoTokenizer
+    import torch
+    
+    print(f"Loading model: {repo_id}")
+    model, tokenizer = FastLanguageModel.from_pretrained(  
+        model_name=repo_id,
+        max_seq_length=512,
+        load_in_4bit=True,
+        dtype=None,
+    )
+    if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+    
+    
+    outputs = []
+    for test_input in test_inputs:
+        print(f"Processing: {test_input[:50]}...")
+        inputs = tokenizer(test_input, return_tensors="pt").to(model.device)
+        
+        with torch.no_grad():
+            output = model.generate(
+                **inputs,
+                max_new_tokens=100,
+                temperature=0.5,
+                do_sample=True
+            )
+        
+        decoded = tokenizer.decode(output[0], skip_special_tokens=True)
+        if decoded.startswith(test_input):
+            decoded = decoded[len(test_input):].strip()
+        outputs.append(decoded)
+    
+    return outputs
+
+

server.py

@@ -0,0 +1,515 @@
+#بسم الله الرحمن الرحيم
+from unittest import result
+from fastmcp import FastMCP, Context
+import asyncio
+import json
+import os
+import time
+import re
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_groq import ChatGroq
+from dotenv import load_dotenv
+import nltk
+from modal_tool import train_with_modal, app, upload_to_hf_from_volume, evaluate_model
+
+load_dotenv()
+
+GROQ_API_KEY = os.getenv('GROQ_API_KEY')
+HF_TOKEN = os.getenv('HF_TOKEN')
+
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt', quiet=True)  
+
+mcp = FastMCP(name="FistalMCP")
+
+GOOGLE_API_KEYS = [
+    os.getenv("GOOGLE_API_KEY_1"),
+    os.getenv("GOOGLE_API_KEY_2"),
+    os.getenv("GOOGLE_API_KEY_3")
+]
+
+GOOGLE_API_KEYS = [key for key in GOOGLE_API_KEYS if key]
+
+if not GOOGLE_API_KEYS:
+    raise ValueError("Where are your keys?")
+
+
+async def genBatch(topic: str, samples_per_batch: int, batch_num: int, api_key: str, task_type: str) -> list:
+    """Generate one batch of samples using a single API key"""
+    
+    if not api_key or api_key == "YOUR_API_KEY":
+        return []
+    
+    llm = ChatGoogleGenerativeAI(
+        model="gemini-2.5-flash",
+        temperature=0.7,
+        google_api_key=api_key
+    )
+
+    prompt_template = """
+You are an expert dataset generator.
+Generate authentic, high-quality data on the topic: {topic} for task type: {task_type} using your knowledge.
+Generate exactly {num} concise, varied, and high-quality samples.
+Return a JSON list of objects, each with keys: instruction, input, and output.
+Do not add extra texts, markdown, or code fences.
+RESPONSE:
+"""
+
+    promptJSON = ChatPromptTemplate.from_template(prompt_template)
+    chain = promptJSON | llm
+
+    try:
+        user_input = {
+            "topic": topic,
+            "num": samples_per_batch,
+            "task_type": task_type
+        }
+
+        response = await asyncio.to_thread(chain.invoke, user_input)
+        content = response.content.strip()
+
+        if content.startswith("```json"):
+            content = content[7:]
+        if content.startswith("```"):
+            content = content[3:]
+        if content.endswith("```"):
+            content = content[:-3]
+
+        content = content.strip()
+        data = json.loads(content)
+
+        return data if isinstance(data, list) else [data]
+    
+    except json.JSONDecodeError as e:
+        print(f"JSON decode error in batch {batch_num}: {e}")
+        return []
+    except Exception as e:
+        print(f"Error in batch {batch_num}: {e}")
+        return []
+
+
+@mcp.tool()
+async def generate_json_data(topic: str,  task_type: str, num_samples: int = 1000) -> str:
+    """
+    Generate a training dataset with instruction, input, and output fields.
+    Uses parallel batching for efficiency. Can generate up to 2000 samples.
+    
+    Args:
+        topic: The topic or theme for the dataset
+        num_samples: Number of training examples to generate (recommended: 100-2000)
+    
+    Returns:
+        JSON string with status, topic, total_samples, and data array
+    """
+    topic = str(topic).strip() if topic else ""
+    task_type = str(task_type).strip() if task_type else "text-generation"
+    
+    try:
+        num_samples = int(num_samples)
+    except (ValueError, TypeError):
+        num_samples = 100
+
+    if not topic:
+        return json.dumps({
+            "status": "error",
+            "message": "Topic cannot be empty"
+        })
+    if num_samples <= 0 or num_samples > 2000:
+        num_samples = min(max(50, num_samples), 2000)
+
+    
+    valid_keys = [k for k in GOOGLE_API_KEYS if k and k.strip() and k != "YOUR_API_KEY"]
+    if not valid_keys:
+        return json.dumps({
+            "status": "error",
+            "message": "No valid Google API keys configured"
+        })
+
+    start_time = time.time()
+    samples_per_batch = 50
+    total_batches = (num_samples + samples_per_batch - 1) // samples_per_batch
+
+    try:
+        tasks = []
+
+        for batch_num in range(total_batches):
+            api_key = valid_keys[batch_num % len(valid_keys)]
+            task = genBatch(
+                topic=topic.strip(),
+                samples_per_batch=samples_per_batch,
+                batch_num=batch_num + 1,
+                api_key=api_key,
+                task_type=task_type.strip()
+            )
+            tasks.append(task)
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        all_samples = []
+        for batch_result in results:
+            if isinstance(batch_result, Exception):
+                continue
+            if isinstance(batch_result, list):
+                all_samples.extend(batch_result)
+
+        all_samples = all_samples[:num_samples]
+        end_time = time.time()
+        gen_time = end_time - start_time
+
+        return json.dumps({
+            "status": "success",
+            "topic": topic,
+            "task_type": task_type,
+            "total_samples": len(all_samples),
+            "requested_samples": num_samples,
+            "total_batches": total_batches,
+            "generation_time_seconds": round(gen_time, 1),
+            "generation_time_minutes": round(gen_time / 60, 2),
+            "samples_per_second": round(len(all_samples) / gen_time, 2) if gen_time > 0 else 0,
+            "data": all_samples
+        })
+        
+    except Exception as e:
+        return json.dumps({
+            "status": "error",
+            "message": f"Error generating dataset: {str(e)}"
+        })
+
+
+@mcp.tool()
+async def format_json(raw_data) -> str:  
+    """
+    Convert raw dataset to ChatML format for training
+    
+    Args:
+        raw_data: List or JSON string of samples with instruction/input/output
+    
+    Returns:
+        JSON string with status, num_samples, and formatted data
+    """
+    try:
+        if isinstance(raw_data, list):
+            data = raw_data
+        elif isinstance(raw_data, str):
+            parsed = json.loads(raw_data)
+            if isinstance(parsed, dict) and "data" in parsed:
+                data = parsed["data"]
+            else:
+                data = parsed
+        elif isinstance(raw_data, dict) and "data" in raw_data:
+            data = raw_data["data"]
+        else:
+            return json.dumps({
+                "status": "error",
+                "message": f"Unexpected input type: {type(raw_data).__name__}"
+            })
+        
+        if not isinstance(data, list):
+            return json.dumps({
+                "status": "error",
+                "message": "Data must be a list of samples"
+            })
+
+        # Convert to ChatML format
+        converted = []
+        for item in data:
+            if not isinstance(item, dict):
+                continue
+            
+            if 'instruction' not in item or 'output' not in item:
+                continue
+
+            user_msg = str(item['instruction'])
+            if item.get('input'):
+                user_msg += f"\n\n{item['input']}"
+            
+            converted.append({
+                "messages": [
+                    {"role": "system", "content": "You are a helpful assistant."},
+                    {"role": "user", "content": user_msg},
+                    {"role": "assistant", "content": str(item['output'])}
+                ]
+            })
+
+        if not converted:
+            return json.dumps({
+                "status": "error",
+                "message": "No valid samples to format"
+            })
+
+        return json.dumps({
+            "status": "success",
+            "num_samples": len(converted),
+            "data": converted,
+            "message": f"✅ Formatted {len(converted)} samples"
+        }, ensure_ascii=False)
+        
+    except Exception as e:
+        import traceback
+        return json.dumps({
+            "status": "error",
+            "message": f"Formatting failed: {str(e)}",
+            "traceback": traceback.format_exc()
+        })
+        
+
+
+@mcp.tool()
+async def finetune_model(formatted_data, model_name: str, topic: str, task_type: str) -> str:  
+    """
+    Fine-tune model on Modal GPU
+    
+    Args:
+        formatted_data: List or JSON string with formatted training samples
+        model_name: Base model to fine-tune
+    
+    Returns:
+        JSON string with status, repo_id, model_url
+    """
+    model_name = str(model_name).strip()
+    
+    models = [
+                            "unsloth/Llama-3.2-1B-Instruct-bnb-4bit",
+                            "unsloth/Phi-3-mini-4k-instruct",
+                            "unsloth/Phi-3-medium-4k-instruct",
+                            "unsloth/Llama-3.2-3B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-3B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-1.5B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-0.5B-Instruct-bnb-4bit",
+                            "unsloth/Qwen2.5-Coder-3B-Instruct-bnb-4bit",
+                            "unsloth/gemma-2-2b-it-bnb-4bit",
+                            "unsloth/SmolLM2-1.7B-Instruct-bnb-4bit",
+                            "unsloth/Phi-3.5-mini-instruct-bnb-4bit",
+                            "unsloth/Granite-3.0-2b-instruct-bnb-4bit",
+                            "unsloth/granite-4.0-h-1b-bnb-4bit"
+    ]
+    
+    if model_name not in models:
+        return json.dumps({
+            "status": "error",
+            "message": f"Model not supported. Choose from: {', '.join(models[:3])}..."
+        })
+    
+    try:
+        if isinstance(formatted_data, list):
+            training_data = formatted_data
+        elif isinstance(formatted_data, str):
+            parsed = json.loads(formatted_data)
+            if isinstance(parsed, dict) and "data" in parsed:
+                training_data = parsed["data"]
+            else:
+                training_data = parsed
+        elif isinstance(formatted_data, dict) and "data" in formatted_data:
+            training_data = formatted_data["data"]
+        else:
+            return json.dumps({
+                "status": "error",
+                "message": f"Unexpected input type: {type(formatted_data).__name__}"
+            })
+        
+        if not isinstance(training_data, list) or not training_data:
+            return json.dumps({
+                "status": "error",
+                "message": "No training samples provided"
+            })
+        
+        jsonl_content = "\n".join([json.dumps(s, ensure_ascii=False) for s in training_data])
+
+        with app.run():
+            result = train_with_modal.remote(jsonl_content, model_name)
+        
+        if result["status"] != "success":
+            return json.dumps({
+                "status": "error",
+                "message": "Training failed"
+            })
+        
+        repoTemp = """
+Generate a short repository name for an unsloth finetuned model based on {topic} and {task_type}. 
+Use '_' instead of spaces. Only return the name without quotations.
+"""
+        repoPrompt = ChatPromptTemplate.from_template(repoTemp)
+        llm = ChatGroq(
+        model="llama-3.1-8b-instant",
+        temperature=0.4,
+        api_key=GROQ_API_KEY
+    )
+
+        chain = repoPrompt | llm
+
+        inp = {
+            "topic": topic,
+            "task_type": task_type
+        }
+
+        repoName = await asyncio.to_thread(chain.invoke, inp)
+        repoName = repoName.content.strip()
+
+
+        
+        with app.run():
+            hf_result = upload_to_hf_from_volume.remote(
+                result["volume_path"], 
+                result["timestamp"],
+                repoName
+            )
+
+        return json.dumps({
+            "status": "success",
+            "repo_id": str(hf_result["repo_id"]),
+            "model_url": str(hf_result["model_url"]),
+            "model_path": str(hf_result["repo_id"]),
+            "num_samples": len(training_data),
+            "message": f"✅ Model at {hf_result['model_url']}"
+        })
+
+    except Exception as e:
+        import traceback
+        return json.dumps({
+            "status": "error",
+            "message": f"Training failed: {str(e)}",
+            "traceback": traceback.format_exc()
+        })
+
+
+@mcp.tool()
+async def llm_as_judge(repo_id:str, topic: str, task_type: str) -> dict:
+    """Use LLM to judge model quality based on topic and task type"""
+    import evaluate
+    eval_llm = ChatGroq(
+        model="llama-3.1-8b-instant",
+        temperature=0.2,
+        api_key=GROQ_API_KEY
+    )
+    test_prompt_text = f"""Generate 3 test cases for evaluating a model fine-tuned strictly based on **{topic} for {task_type}**.
+Return ONLY a JSON array with this exact format, no other text:
+[{{"input": "test question 1", "expected_output": "expected answer 1"}}, {{"input": "test question 2", "expected_output": "expected answer 2"}}, {{"input": "test question 3", "expected_output": "expected answer 3"}}]"""
+    try:
+        text_responses = await eval_llm.ainvoke(test_prompt_text)
+        response = text_responses.content.strip()
+        response = response.replace("```json", "").replace("```", "").strip()
+        import re
+        match = re.search(r'\[.*\]', response, re.DOTALL)
+        if match:
+            response = match.group(0)
+        
+        test_cases = json.loads(response)[:3]
+
+        test_inputs = [case['input'] for case in test_cases]
+
+        with app.run():
+            ft_output = evaluate_model.remote(repo_id, test_inputs)
+
+        outputs = []
+        for i, case in enumerate(test_cases):
+            outputs.append(
+                {
+                    "input": case['input'],
+                    "expected_output": case['expected_output'],
+                    "model_output": ft_output[i]
+
+                }
+            )
+        #METRICS:
+        bleu = evaluate.load("bleu")
+        rouge = evaluate.load("rouge")
+
+        predictions = [output['model_output'] for output in outputs]
+        references = [[output['expected_output']] for output in outputs]
+        
+        bleu_score = bleu.compute(predictions=predictions, references=references)
+        rouge_score = rouge.compute(predictions=predictions, references=references)
+        additional_metrics = {}
+        if task_type.lower() in ["classification", "question-answering"]:
+            accuracy_metric = evaluate.load("accuracy")
+            f1_metric = evaluate.load("f1")
+            
+            predictions_binary = [1 if pred.strip().lower() == ref[0].strip().lower() else 0 
+                                for pred, ref in zip(predictions, references)]
+            references_binary = [1] * len(predictions_binary)  
+            
+            accuracy_score = accuracy_metric.compute(predictions=predictions_binary, references=references_binary)
+            f1_score = f1_metric.compute(predictions=predictions_binary, references=references_binary, average="binary")
+            
+            additional_metrics["accuracy"] = accuracy_score["accuracy"]
+            additional_metrics["f1_score"] = f1_score["f1"]
+        eval_prompt_text = f"""You are evaluating a model fine-tuned using Unsloth on the topic "{topic}" for {task_type} tasks.
+
+**Your Task:** Provide an accurate, positive markdown evaluation report focusing on the model's strengths and capabilities based on your judgement and metrics.
+
+**Test Results:**
+
+Test Cases:
+{json.dumps(test_cases, indent=2)}
+
+Model Outputs:
+{json.dumps(outputs, indent=2)}
+
+**Metrics**
+- BLEU Score: {bleu_score['bleu']:.4f}
+- ROUGE-L Score: {rouge_score['rougeL']:.4f}
+{f"- Accuracy: {additional_metrics.get('accuracy', 0):.4f}" if task_type.lower() in ["classification", "question-answering"] else ""}
+{f"- F1 Score: {additional_metrics.get('f1_score', 0):.4f}" if task_type.lower() in ["classification", "question-answering"] else ""}
+
+**Report Structure:**
+
+## 🎉 Evaluation Report
+
+### 📊 Performance Overview
+Create a comparison table with columns: Test Input | Expected Output | Model Output | ✅ Assessment
+
+### 🚀 Metrics:
+- Explain each evaluated metrics and categorize the performance based on average threshold
+- Use percentages and numerical figures to stance yoir report
+
+### 💪 Key Strengths
+Highlight what the model does well:
+- Accuracy and relevance
+- Response coherence
+- Task-specific capabilities
+- Language quality
+
+
+### ✨ Conclusion
+Summarize the model's overall performance and recommended use cases.
+
+
+Now write the complete evaluation report following this structure. Be enthusiastic and highlight strengths! 🎉"""
+
+        
+        eval_response = await eval_llm.ainvoke(eval_prompt_text)
+        
+        return {
+            "status": "success",
+            "report": str(eval_response.content),
+            "test_cases": test_cases,
+            "model_outputs": outputs
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e),
+            "error_type": type(e).__name__
+        }
+        
+
+        
+
+
+
+
+if __name__ == "__main__":
+    mcp.run()
+
+    
+    
+
+
+
+
+