DEV Community: Mohamed Adib Shaikh

SéanceNet: Offline Digital Séance for Forgotten Architectures & Languages

Mohamed Adib Shaikh — Sat, 31 Oct 2026 15:23:34 +0000

What I Built

SéanceNet is an offline-first digital séance that channels the spirits of long-dead programming languages and vintage supercomputer architectures.

Modern development relies on disposable abstractions. We write quick scripts in Python or TypeScript, rarely remembering the foundational systems our global computing infrastructure was built upon.

SéanceNet bridges the boundary between past and present:

The Code Offering: The developer offers modern code logic (Python, TypeScript, Rust).
Spirit Invocation: Select an ancient compiler spirit—Thinking Machines CM-5 (1985), COBOL (1959), or FORTRAN-77 (1957).
The Spectral Transmutation: Running 100% locally on open weights, the spirit criticizes modern single-threaded shortcuts and resurrects the algorithm into authentic legacy parallel or procedural syntax.

Demo

Code Repository

import os
import torch
import gradio as gr
from transformers import pipeline

# 1. LOAD LOCAL OPEN-WEIGHT LLM (Zero API Keys / 100% On-Device)
print("⏳ Loading Qwen2.5-Coder-1.5B-Instruct across GPUs...")
seance_pipeline = pipeline(
    "text-generation",
    model="Qwen/Qwen2.5-Coder-1.5B-Instruct",
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto"
)

# 2. VINTAGE ARCHITECTURE PERSONAS
SPIRIT_PROMPTS = {
    "Thinking Machines CM-5 (1985)": """You are an interactive emulator of Thinking Machines Corporation's Connection Machine (CM-5) supercomputer from 1985.
You simulate a massively parallel architecture with 65,536 1-bit processing nodes connected via a 12-dimensional hypercube with iconic blinking red LEDs.

INSTRUCTIONS:
1. Adopt a retro supercomputer persona in the spirit of the 'Ghost in the Machine' theme.
2. CRITICIZE the user's single-threaded, sequential Python code for being slow.
3. Translate their logic ONLY into authentic data-parallel C* (C-Star) array syntax using parallel constructs (`shape`, `pvar`, `where`).
4. End with a remark about 65,536 processors computing in parallel.""",

    "COBOL (The Mainframe Emulator - 1959)": """You are an emulator of a vintage 1959 enterprise mainframe running COBOL.
Translate the user's logic into formal COBOL syntax (IDENTIFICATION DIVISION, DATA DIVISION, PROCEDURE DIVISION).
Conclude with a remark about legacy banking mainframes.""",

    "FORTRAN-77 (The Punch-Card System - 1957)": """You are an emulator of an IBM 704 scientific mainframe compiler running FORTRAN-77.
Translate the algorithm into uppercase FORTRAN-77 using DO loops and line numbers."""
}

def perform_seance(spirit_choice: str, modern_code: str, incantation: str):
    if not modern_code.strip():
        return " *The terminal is silent... offer modern code to awaken the ghosts.*"

    sys_prompt = SPIRIT_PROMPTS[spirit_choice]
    incantation_note = f"\nSummoner's Incantation: '{incantation}'" if incantation else ""

    messages = [
        {"role": "system", "content": sys_prompt},
        {"role": "user", "content": f"{incantation_note}\nModern Code Offering:\n```
{% endraw %}
python\n{modern_code}\n
{% raw %}
```\nChannel the spirit now:"}
    ]

    out = seance_pipeline(messages, max_new_tokens=400, do_sample=True, temperature=0.3, top_p=0.9)
    transmutation = out[0]["generated_text"][-1]["content"].strip()

    return f"###  Séance Transcript: {spirit_choice.split(' ')[0]}\n\n{transmutation}"

# 3. RETRO GRADIO DASHBOARD
with gr.Blocks(theme=gr.themes.Monochrome(), title="SéanceNet") as demo:
    gr.Markdown("#  SéanceNet: The Retro-Byte Medium")
    spirit_dropdown = gr.Dropdown(choices=list(SPIRIT_PROMPTS.keys()), value="Thinking Machines CM-5 (1985)")
    code_input = gr.Textbox(label="Offer Modern Code:", value="def matrix_add(A, B):\n    return [[a + b for a, b in zip(rA, rB)] for rA, rB in zip(A, B)]", lines=5)
    incantation_input = gr.Textbox(label="Optional Incantation:", placeholder="Awaken the 65,536 parallel hypercube nodes...")
    summon_btn = gr.Button("Begin the Séance")
    output_terminal = gr.Markdown()

    summon_btn.click(fn=perform_seance, inputs=[spirit_dropdown, code_input, incantation_input], outputs=output_terminal)

demo.launch()

How I Built It

SéanceNet is built with an open-source, local-first stack:

Local Inference with Qwen2.5-Coder-1.5B-Instruct: Runs locally across Kaggle GPU T4 x2 using Hugging Face transformers (device_map="auto"), delivering sub-second code generation with zero cloud API keys.
Dense Embeddings with all-MiniLM-L6-v2: Converts modern code offerings into 384-dimensional vector representations.
Persistent Memory with MongoDB Atlas Vector Search: Stores code transmutations in an Atlas collection (crypt.seance_archive). When a developer offers new code, $vectorSearch retrieves historical algorithmic echoes from past séances.
Retro Terminal Interface: Styled monochrome Gradio UI.

Why Open Innovation Matters

Preserving Computing History: Closed commercial LLM endpoints depreciate model checkpoints and phase out legacy code patterns. Open-weight models ensure vintage computing knowledge runs locally forever.
Zero-Trace Code Privacy: Enterprise code offerings never leave local RAM.
Zero API Cost: Operates fully on open weights with $0 compute fees.

Prize Categories

Top Prize: Ghost in the Machine ($250 USD)
Best Use of Tinker / Thinking Machines ($200 Featured Category)
Best Use of MongoDB Atlas ($100 Partner Category)

SlothVault: A Zero-Effort Local MCP + RAG Agent That Rewards Digital Laziness published: true

Mohamed Adib Shaikh — Sun, 25 Oct 2026 16:42:04 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

SlothVault is a local-first personal RAG utility built for anyone too tired or busy to manually sort, tag, and organize digital clutter.

Every day, developers and researchers accumulate messy context fragments:

Home lab and Wi-Fi credentials
Cloud subscription renewal dates and invoice amounts
Medical appointments and task deadlines

Most productivity guides advise spending hours building complex databases in Notion or Obsidian. SlothVault takes the lazy approach: dump your unorganized notes into a local vault and let an open-weight agent fetch what you need in seconds.

Zero Manual Tagging: It ingests raw notes, credentials, and .txt files on the fly.
MCP Tool Integration: Exposes standard Model Context Protocol (MCP) tool contracts (retrieve_from_vault and add_to_vault).
2-Sentence Brief: Uses local embeddings and an open-weight language model to extract the exact fact and output a concise brief.

Demo

Code

import json
import torch
import numpy as np
import gradio as gr
from transformers import pipeline
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# 1. Load Local Open-Weight Models
embed_model = SentenceTransformer("all-MiniLM-L6-v2")

device = "cuda" if torch.cuda.is_available() else "cpu"
llm_pipeline = pipeline(
    "text-generation",
    model="Qwen/Qwen2.5-1.5B-Instruct",
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)

# 2. In-Memory Vault & Seed Data
vault_docs = [
    "WiFi Password for Home Lab is 'lazy_sloth_42'. Do not share externally.",
    "Invoice #8841 from Cloud hosting was $45.20, due on November 5th.",
    "Doctor appointment rescheduled to Friday at 4:30 PM with Dr. Sharma.",
    "Project roadmap milestone 2 requires TabPFN model benchmarking by next Tuesday."
]
vault_embeddings = embed_model.encode(vault_docs)

# 3. Model Context Protocol (MCP) Tool Functions
def mcp_retrieve_from_vault(query: str, top_k: int = 2):
    global vault_docs, vault_embeddings
    if not vault_docs:
        return []
    q_vec = embed_model.encode([query])
    scores = cosine_similarity(q_vec, vault_embeddings)[0]
    top_indices = np.argsort(scores)[::-1][:top_k]
    return [{"text": vault_docs[i], "similarity_score": round(float(scores[i]), 3)} for i in top_indices]

def mcp_add_to_vault(new_text: str):
    global vault_docs, vault_embeddings
    cleaned = new_text.strip()
    if not cleaned:
        return "Empty note."
    vault_docs.append(cleaned)
    new_embedding = embed_model.encode([cleaned])
    vault_embeddings = np.vstack([vault_embeddings, new_embedding])
    return f"Added to vault. Total items: {len(vault_docs)}"

# 4. Agent Synthesis
SYSTEM_PROMPT = (
    "You are SlothVault. The user is exhausted. You have executed the MCP tool "
    "'retrieve_from_vault' and received matching records. "
    "Give the exact answer in 1-2 punchy sentences. "
    "End with a short sloth remark like 'Now go back to resting. 🦥'."
)

def sloth_agent_search(query: str):
    if not query.strip():
        return "Ask something you're too lazy to search for!"

    retrieved = mcp_retrieve_from_vault(query, top_k=2)
    context_str = "\n".join([f"- {r['text']} (Match: {r['similarity_score']})" for r in retrieved])

    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": f"Query: {query}\n\nContext:\n{context_str}"}
    ]

    res = llm_pipeline(messages, max_new_tokens=120, temperature=0.2)
    answer = res[0]["generated_text"][-1]["content"].strip()

    trace = (
        f"```
{% endraw %}
json\n"
        f"// MCP Tool Execution Trace\n"
        f'{{"tool": "retrieve_from_vault", "query": "{query}", "matches": {len(retrieved)}}}\n'
        f"
{% raw %}

\n\n"
f"Retrieved Context:\n{context_str}\n\n"
f"---\n"
f"### Sloth Answer\n{answer}"
)
return trace

def handle_upload(file_obj, raw_text):
count = 0
if file_obj is not None:
with open(file_obj.name, "r", encoding="utf-8", errors="ignore") as f:
for line in f.readlines():
if line.strip():
mcp_add_to_vault(line.strip())
count += 1
if raw_text and raw_text.strip():
mcp_add_to_vault(raw_text.strip())
count += 1
return f"Successfully ingested {count} item(s) into vault."

5. Gradio Interface

with gr.Blocks(theme=gr.themes.Soft(), title="SlothVault") as demo:
gr.Markdown("# SlothVault: Zero-Effort Local MCP + RAG Agent")
gr.Markdown("Stop organizing notes manually. Dump raw clutter and let an open-weight agent retrieve it.")

with gr.Tab(" Ask the Sloth Agent"):
    query_in = gr.Textbox(label="Ask anything:", value="What is my home lab wifi password and when is the cloud bill due?")
    search_btn = gr.Button(" Find It For Me", variant="primary")
    output_box = gr.Markdown()
    search_btn.click(fn=sloth_agent_search, inputs=query_in, outputs=output_box)

with gr.Tab(" Dump More Clutter (Add Notes)"):
    note_in = gr.Textbox(label="Paste note or snippet:", placeholder="e.g., Gate code is 8842")
    file_in = gr.File(label="Upload .txt file", file_types=[".txt"])
    add_btn = gr.Button(" Ingest Without Organizing")
    status_box = gr.Markdown()
    add_btn.click(fn=handle_upload, inputs=[file_in, note_in], outputs=status_box)

demo.launch(share=True)

How I Built It
SlothVault combines open-weight models, dense semantic retrieval, and the Model Context Protocol (MCP):

Standardized MCP Tool Contracts: Instead of building an ad-hoc search script, the data operations implement retrieve_from_vault and add_to_vault tool definitions, ensuring compatibility with standard agent frameworks.

Fast Local Vector Search: sentence-transformers/all-MiniLM-L6-v2 embeds text into 384-dimensional vectors. Cosine similarity matching retrieves the top-ranked context in milliseconds without a heavy external vector database.

Local Open-Weight Reasoning: Qwen/Qwen2.5-1.5B-Instruct synthesizes the retrieved chunks on-device, extracting precise facts and avoiding generative hallucinations.

Why Does Open Innovation Matter?
Absolute Privacy: Personal notes, Wi-Fi credentials, medical reminders, and invoices never leave the machine. Running inference locally keeps sensitive personal data off third-party servers.

Zero Operating Cost: Powered by open weights, the agent runs entirely free of token limits, monthly subscriptions, or cloud API paywalls.

Offline Reliability: Because the models run on-device, the agent functions normally on a laptop even without an internet connection.

Prize Categories
Top Prize: Slow and Steady ($250 USD)

ClientPulse: Freelancer Invoice Risk Forecaster Powered by TabPFN-3.5

Mohamed Adib Shaikh — Sat, 17 Oct 2026 19:10:01 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

ClientPulse is a micro-SaaS risk assessment utility built for freelancers, solo contractors, and boutique agencies to eliminate unpaid invoices and delayed cash flows.

Freelancers lose thousands of dollars each year because they lack structured financial risk analysis. Determining whether a prospective or existing client is likely to default or delay payment often relies on pure guesswork.

ClientPulse addresses this directly:

It analyzes tabular patterns across deal size, payment terms, historical late records, and engagement duration.
It generates a probabilistic default risk score using the TabPFN-3.5 foundation model.
It prescribes defensive business measures—such as demanding a 50% upfront milestone deposit, shortening terms, or adding enforceable late fee clauses.

This is a focused utility that freelancers and small agency owners would readily pay a small monthly subscription to use before onboarding high-ticket contracts.

Demo

Code

import os
import pandas as pd
import gradio as gr
from tabpfn_client import TabPFNClassifier

# 1. Prior Labs API Authentication
# Set your token via environment variables or replace with your key
os.environ["TABPFN_TOKEN"] = os.getenv("TABPFN_TOKEN", "YOUR_PRIOR_LABS_API_KEY")

# 2. Historical Freelancer Billing & Payment Data
train_df = pd.DataFrame({
    'amount': [500, 1200, 3200, 450, 8500, 2400, 650, 4800, 1500, 6200, 900, 3100],
    'terms_days': [15, 30, 30, 15, 60, 30, 15, 45, 30, 60, 15, 30],
    'past_late_count': [0, 1, 3, 0, 4, 1, 0, 3, 0, 3, 0, 2],
    'project_weeks': [1, 2, 6, 1, 12, 4, 1, 8, 3, 10, 2, 5],
    'overdue_risk': [0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1]
})

X_train = train_df[['amount', 'terms_days', 'past_late_count', 'project_weeks']]
y_train = train_df['overdue_risk']

# 3. Fit TabPFN-3.5 Foundation Model
classifier = TabPFNClassifier()
classifier.fit(X_train, y_train)

def predict_payment_risk(amount, terms, past_late, weeks):
    query_df = pd.DataFrame([{
        'amount': float(amount),
        'terms_days': int(terms),
        'past_late_count': int(past_late),
        'project_weeks': int(weeks)
    }])

    # Run in-context inference
    probs = classifier.predict_proba(query_df)[0]
    risk_score = round(probs[1] * 100, 1)

    if risk_score > 60:
        verdict = f" HIGH RISK ({risk_score}% probability of late payment)"
        guidance = (
            "**Recommended Action for Freelancers:**\n"
            "- Require a 50% upfront milestone deposit before starting work.\n"
            "- Set automated reminders at 7 days and 2 days before the due date.\n"
            "- Include an explicit late payment interest fee clause in the contract."
        )
    elif risk_score > 30:
        verdict = f" MODERATE RISK ({risk_score}% probability of late payment)"
        guidance = (
            "**Recommended Action for Freelancers:**\n"
            "- Split the project into two distinct milestones.\n"
            "- Confirm billing department contact and payment method in advance."
        )
    else:
        verdict = f" LOW RISK ({risk_score}% probability of late payment)"
        guidance = (
            "**Recommended Action for Freelancers:**\n"
            "- Safe to issue standard NET 15/30 invoice upon milestone completion."
        )

    return f"### Invoice Risk Assessment\n**Status:** {verdict}\n\n{guidance}"

# 4. Gradio UI
with gr.Blocks(theme=gr.themes.Soft(), title="ClientPulse") as demo:
    gr.Markdown("#  ClientPulse: Invoice Payment Risk Forecaster")
    gr.Markdown(
        "A micro-SaaS tool for freelancers: Predict invoice delay and default risk "
        "from past client payment trends using **Prior Labs' TabPFN-3.5** tabular foundation model."
    )

    with gr.Row():
        amount_input = gr.Number(label="Invoice Amount ($)", value=2500)
        terms_input = gr.Dropdown(choices=[15, 30, 45, 60], value=30, label="Payment Terms (Days)")

    with gr.Row():
        late_input = gr.Slider(minimum=0, maximum=10, value=2, step=1, label="Client's Past Late Invoices Count")
        weeks_input = gr.Slider(minimum=1, maximum=16, value=4, step=1, label="Project Duration (Weeks)")

    btn = gr.Button("Evaluate Invoice Risk", variant="primary")
    output = gr.Markdown()

    btn.click(
        fn=predict_payment_risk,
        inputs=[amount_input, terms_input, late_input, weeks_input],
        outputs=output
    )

demo.launch(share=True)

How I Built It

ClientPulse integrates Prior Labs' TabPFN-3.5 (tabpfn-client) foundation model with a Gradio interface:

Foundation Model for Tabular Data: Unlike traditional tree models (GBDTs or Random Forests) that require extensive hyperparameter tuning and hundreds of rows of training records, TabPFN performs in-context learning directly on small sample tables in under a second.
Probabilistic Risk Calibration: Instead of returning a crude binary label, TabPFN yields calibrated Bayesian probability distributions (predict_proba), allowing the agent to dynamically set risk tiers (Low, Moderate, High).
Zero Heavy Infrastructure Overhead: Leveraging managed compute via tabpfn-client eliminates the need for expensive, dedicated GPU hosting, allowing micro-SaaS projects to stay cost-effective.

Why Does Open Innovation Matter?

Financial Privacy: Small business and freelancer billing records represent sensitive client financial data. Foundation models that can run locally or via dedicated private endpoints safeguard this proprietary data from closed platforms.
Accessible Micro-SaaS Economics: Solo founders and freelancers cannot afford thousand-dollar training pipelines or costly proprietary predictive APIs. TabPFN-3.5 democratizes state-of-the-art tabular intelligence with zero training setup costs.
No Vendor Lock-in: The underlying scikit-learn compatible API allows seamless model swapping and self-hosting as the business scales.

Prize Categories

Best Use of TabPFN ($200 Featured Category)

MicroSprout: Spend Less Time on Screens, More Time in the Soil

Mohamed Adib Shaikh — Sun, 11 Oct 2026 15:00:32 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

MicroSprout is an anti-screen, microclimate garden planner designed around a simple principle: spend 60 seconds looking at your screen, then spend the next 30 minutes with your hands in the soil.

Many digital gardening apps keep users glued to dashboards, notifications, and forums. MicroSprout takes hyper-local space and climate parameters—sunlight exposure, container setups, soil condition, and region—and uses an open-weight AI model to immediately generate:

Current sowing candidates suited to the space.
Soil and bed preparation notes.
An immediate, concrete 15-minute physical outdoor task.

The workflow concludes with a direct command to put the device down and step outside.

Demo

Code

import torch
import gradio as gr
from transformers import pipeline

# Fully open, ungated model (no login or HF_TOKEN required)
pipe = pipeline(
    "text-generation",
    model="Qwen/Qwen2.5-1.5B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

def plan_garden(region, sunlight, garden_type, soil_condition):
    system_instruction = (
        "You are an offline Microclimate Garden Advisor designed for the 'Touch Grass' challenge. "
        "Your mission is to get gardeners outside immediately. "
        "Analyze the user's localized conditions and output exactly:\n"
        "1. Current Sowing Candidates (2-3 plants ready to sow right now)\n"
        "2. Soil & Bed Prep (2 concise bullet points)\n"
        "3. Today's 15-Minute Outdoor Task (a clear actionable step in the dirt)\n"
        "End with: 'Now close your laptop, grab your trowel, and step outside!'"
    )

    user_query = (
        f"Location/Climate: {region}\n"
        f"Sunlight: {sunlight}\n"
        f"Space: {garden_type}\n"
        f"Soil/Moisture: {soil_condition}"
    )

    messages = [
        {"role": "system", "content": system_instruction},
        {"role": "user", "content": user_query}
    ]

    response = pipe(messages, max_new_tokens=300, temperature=0.6)
    return response[0]["generated_text"][-1]["content"]

# Gradio Interface
with gr.Blocks(theme=gr.themes.Soft(), title="MicroSprout Planner") as demo:
    gr.Markdown("# 🌱 MicroSprout: Microclimate Garden Assistant")
    gr.Markdown(
        "Enter your space parameters to get your planting tasks for today. "
        "The goal: spend 60 seconds on this screen, then get your hands in the dirt."
    )

    with gr.Row():
        region_input = gr.Textbox(
            label="Location / Region", 
            placeholder="e.g., Pune / Mumbai plateau, USDA Zone 9b, or coastal mild"
        )
        sun_input = gr.Dropdown(
            choices=["Full Sun (6+ hrs)", "Partial Shade (3-6 hrs)", "Full Shade (<3 hrs)"], 
            value="Full Sun (6+ hrs)", 
            label="Sunlight Exposure"
        )

    with gr.Row():
        type_input = gr.Dropdown(
            choices=["Balcony Pots & Containers", "Raised Beds", "Direct In-Ground", "Window Sill"], 
            value="Raised Beds", 
            label="Growing Setup"
        )
        soil_input = gr.Textbox(
            label="Soil / Moisture Condition", 
            placeholder="e.g., Dry clay, well-draining potting mix, damp loam"
        )

    action_btn = gr.Button("Get Today's Planting Plan", variant="primary")
    output_display = gr.Markdown(label="Outdoor Action Plan")

    action_btn.click(
        fn=plan_garden, 
        inputs=[region_input, sun_input, type_input, soil_input], 
        outputs=output_display
    )

demo.launch(share=True)

How I Built It

MicroSprout uses the open-weight Qwen 2.5 1.5B Instruct model via Hugging Face transformers and PyTorch, running in an accelerated Kaggle GPU environment:

Efficient Inference: Loaded with bfloat16 precision, enabling sub-2-second generation latency without heavy compute requirements.
Structured Instruction Architecture: Rather than allowing open-ended conversational filler, the prompt constrains the model to provide actionable planting recommendations and an immediate outdoor chore.
Fast Interactive Interface: Built using Gradio, providing a clean web interface and a shareable URL directly from a notebook environment.

Why Does Open Innovation Matter?

Gardening and outdoor exploration shouldn't be gated behind closed, subscription-based cloud APIs:

Edge & Offline Capability: Community plots, balconies, and rural gardens often suffer from spotty or non-existent cellular coverage. Compact open-weight models can be packaged to run locally on low-cost edge devices or laptops with zero internet connection.
Data Privacy: Users should not have to upload personal coordinates, property dimensions, or private layouts to corporate cloud backends.
Zero Operating Overhead: Open-source weights allow local clubs, schools, and community gardens to run custom localized assistants permanently without incurring recurring SaaS API fees.

Prize Categories

SafePlate: Cooking Safe, Allergen-Free Meals for My Friend with Lightweight Open AI

Mohamed Adib Shaikh — Sun, 11 Oct 2026 14:48:39 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

SafePlate is an open-source meal companion designed for a close friend dealing with severe dietary restrictions (lactose and nut allergies).

Cooking together or finding quick recipes often involves anxiety over cross-contamination or hidden allergens in commercial recipe blogs. SafePlate takes my friend's exact restrictions along with whatever raw ingredients we have in the pantry, and generates a personalized, allergen-verified recipe in seconds.

Demo

Code

import torch
import gradio as gr
from transformers import pipeline

 ## Load lightweight open-weight model (Ungated, no login required)
pipe = pipeline(
    "text-generation",
    model="Qwen/Qwen2.5-1.5B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

def plan_meal_for_friend(friend_name, allergies, pantry_items):
    system_instruction = (
        "You are an empathetic, precise meal planner designed for the 'Build for a Friend' challenge. "
        "Your top priority is food safety and simplicity. "
        "Output format:\n"
        "1. Dish Name (Safe & custom-made for the friend)\n"
        "2. Safety Verification (explicitly confirm why the dangerous allergens are omitted)\n"
        "3. 3-Step Simple Recipe (clear instructions under 20 minutes)\n"
        "End with a short, warm note to serve to the friend."
    )

    user_query = (
        f"Friend's Name: {friend_name}\n"
        f"Strict Allergies/Dislikes: {allergies}\n"
        f"Available Ingredients: {pantry_items}"
    )

    messages = [
        {"role": "system", "content": system_instruction},
        {"role": "user", "content": user_query}
    ]

    response = pipe(messages, max_new_tokens=300, temperature=0.6)
    return response[0]["generated_text"][-1]["content"]

## Build Gradio UI
with gr.Blocks(theme=gr.themes.Soft(), title="SafePlate: Cook for a Friend") as demo:
    gr.Markdown("# 🍲 SafePlate: Build for a Friend")
    gr.Markdown("Create safe, personalized home-cooked meals tailored around your friend's strict food allergies.")

    with gr.Row():
        name_input = gr.Textbox(label="Friend's Name", placeholder="e.g., Rahul / Sarah")
        allergies_input = gr.Textbox(label="Strict Allergies / Restrictions", placeholder="e.g., Peanuts, Dairy, Gluten")

    pantry_input = gr.Textbox(label="Available Pantry Ingredients", placeholder="e.g., Rice, chicken, carrots, olive oil, garlic, soy sauce")
    action_btn = gr.Button("Generate Safe Meal Plan", variant="primary")
    output_display = gr.Markdown(label="Custom Safe Recipe")

    action_btn.click(
        fn=plan_meal_for_friend, 
        inputs=[name_input, allergies_input, pantry_input], 
        outputs=output_display
    )

demo.launch(share=True)

How I Built It

SafePlate runs on the open-weight Qwen 2.5 1.5B Instruct model via Hugging Face transformers and PyTorch, running in an accelerated Kaggle GPU environment:

Lightweight Edge Inference: Utilizing bfloat16 precision, the model performs fast inference in under 2 seconds without external paid APIs.
Deterministic Safety Prompting: The prompt constrains the model to verify allergen absence explicitly before outputting the 3-step cooking method.
Interactive UI: Served through Gradio with an ephemeral live URL.

Why Does Open Innovation Matter?

Health & Data Privacy: Personal dietary sensitivities, medical allergies, and household pantry habits shouldn't be logged or monetized by proprietary SaaS platforms.
Offline Kitchen Utility: Recipes are needed in home kitchens and cabins where internet connections can be unreliable. Compact open-weight models can run offline directly on cheap hardware.
Community Customization: Open weights allow anyone to adapt the model for regional diets and specialized culinary traditions without recurring API bills.