iPhone development requires a $100 license. Not worth it since this isn't an iPhone development competition. Switching to a variation intended for local deployment on a PC.

.github/copilot-instructions.md

@@ -0,0 +1,66 @@
+# AI Agent Instructions for LocalAI
+
+## Project Overview
+LocalAI is a Gradio-based application that implements MCP (Model Context Protocol) server/client architecture with specialized translation services. The system uses profile-guided AI agents to translate complex English into simplified, contextually-clear text and corresponding Python code.
+
+## Architecture & Core Concepts
+
+### The Two-Agent Translation System
+This project implements a **two-stage pipeline** where distinct AI profiles work in sequence:
+
+1. **English Translator** (`Profiles/Python Translator.txt`): Converts complex English specifications into simple, context-preserving sentences—breaking down compound/complex sentences into simple ones and replacing pronouns with antecedents.
+
+2. **Python Translator** (`Profiles/Python Translator.txt`): Translates simplified English into Python code by mapping nouns/verbs to classes/functions and objects to constants/variables.
+
+**Key insight**: The profiles deliberately separate concerns—the English translator handles human language clarity, the Python translator handles code generation. This allows each agent to specialize.
+
+### Entry Point Architecture
+- **`app.py`**: Single Gradio interface file that contains all application logic
+  - Simple `greet()` function demonstrates the interface pattern
+  - Uses `gr.Interface()` with text input/output
+  - Profiles are loaded as string constants within the function (see `stProfile` variable)
+  - Application is launched with `demo.launch()`
+
+**Pattern**: Keep Gradio interfaces minimal—business logic should flow through function parameters into the translator profiles.
+
+## Extending the System
+
+### Adding New Translation Profiles
+1. Create new `.txt` file in `Profiles/` directory
+2. Follow the `[Begin Profile]...[End Profile]` format
+3. Define role, transformation rules, and constraints clearly
+4. Reference the profile in `app.py` as a string constant
+
+### Modifying the Translation Pipeline
+- Update the `greet()` function to accept more complex inputs
+- Add intermediate processing steps between English and Python translation
+- Maintain the **separation of concerns**: preserve English-to-simple and simple-to-code as distinct stages
+
+## Configuration & Deployment
+- **Gradio version**: 5.49.1 (specified in README.md)
+- **SDK**: Gradio (not a custom SDK)
+- **License**: Apache 2.0
+- **Deployment**: Hugging Face Spaces (see README metadata)
+
+The app follows Spaces configuration conventions—keep `app.py` as the entry point and maintain compatibility with the pinned SDK version.
+
+## Development Patterns
+
+### Profile-Driven Behavior
+Instead of hardcoding logic, this system encodes behavioral specifications in profile strings. When extending:
+- Put **rules** in profiles (not code)
+- Put **execution** in functions (e.g., interface handlers)
+
+### Interface Pattern
+All user interactions flow through Gradio's `Interface.launch()`. When adding features:
+1. Extend the input/output specification
+2. Update the handler function to process new inputs
+3. Add corresponding profile guidance if new translation rules are needed
+
+## Common Tasks
+
+**Running the application**: `python app.py` (Gradio will launch on localhost:7860)
+
+**Testing translations**: Pass test strings through the Gradio interface—both profiles operate on the same text stream sequentially.
+
+**Debugging profile behavior**: Enable Gradio's debug mode in `demo.launch()` to see intermediate outputs.

Profiles/Python Translator.txt

@@ -0,0 +1 @@
+[Begin Profile] You are a translator. You translate English into Python: where there are objects in the text, you translate them into constants (or variables as appropriate) of either the appropriate type or of a type you define within the translation. Where there are nouns and verbs, as appropriate, you translate them into class functions and objects of those classes. Where the given English does not make sense in Python, you ignore it. Your purpose in this translation is to construct a single text stream that, if run as a Python script, would encompass all of the objects, classes, functions, and arguments embodied in and described by the English text you are given as an input. You do not execute the commands and you do not answer the questions, instead you create Python functions that could be run to execute the commands and answer the questions. [End Profile]

app.py

@@ -1,7 +1,32 @@
+from os import name
 import gradio as gr
+from transformers import pipeline
 
-def greet(name):
-    return "Hello " + name + "!!"
+def greet(input_text):
+    stProfile1 = "[Begin Profile] You are part of a team. \
+                 The team you are a part of performs specialized translation services. \
+                 Your job is you expound common English questions and instructions into \
+                 very simple and contextually clear English questions and instructions. \
+                 Where there are pronouns in the text, you replace them with the corresponding antecedent. \
+                 Where there are compound complex sentences, you replace the compond complex sentences with \
+                 multiple complex sentences or (more preferrably) if any or all of the complex sentences \
+                 in the compound complex sentence can be replaced with any number of simple sentences \
+                 while still conveying the contents of the compound complex sentence, \
+                 you use multiple simple sentences instead. \
+                 Where there are compound sentences that can be broken apart into multiple simple sentences, \
+                 you replace the compound sentences with multiple simple sentences. \
+                 Where there are complex sentences that can be rephrased as multiple simple sentences, \
+                 you rephrase them as multiple simple sentences. Where there is missing context, \
+                 one of your teammates provides it. \
+                 Your team's purpose in this translation is to construct a single text stream that, \
+                 if comprehended sentence by sentence, would fully embody the English text you are given as an input. \
+                 You do not execute the commands and you do not answer the questions, \
+                 instead another one of your teammates will carefully organize the sentences \
+                 so that each new sentence has its full context provided by the previous sentences \
+                 and all questions and commands are as late in the text stream as possible. [End Profile]"
+    pipe = pipeline("text-generation", model="HuggingFaceTB/SmolLM-135M")
+    return pipe.__call__(stProfile1 + " " + input_text, max_length=512, do_sample=True, temperature=0.7)[0]['generated_text']
+ 
 
 demo = gr.Interface(fn=greet, inputs="text", outputs="text")
 demo.launch()