ai

.env.example

@@ -0,0 +1,12 @@
+# API Keys for LLM-based optimization
+# Get your AIMLAPI key from: https://aimlapi.com
+AIMLAPI_API_KEY=your_aimlapi_key_here
+
+# Get your Tavily API key from: https://tavily.com  
+TAVILY_API_KEY=your_tavily_key_here
+
+LANGSMITH_TRACING="true"
+LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
+LANGSMITH_API_KEY=""
+LANGSMITH_PROJECT=""
+

Dockerfile

@@ -17,4 +17,4 @@ EXPOSE 8501
 
 HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+ENTRYPOINT ["streamlit", "run", "src/app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1,19 +1,70 @@
 ---
-title: McpOptimizer
+title: AI Prompt Optimizer
 emoji: 🚀
-colorFrom: red
-colorTo: red
+colorFrom: blue
+colorTo: green
 sdk: docker
 app_port: 8501
 tags:
 - streamlit
+- ai
+- llm
+- optimization
+- prompt-engineering
 pinned: false
-short_description: Streamlit template space
+short_description: Advanced AI prompt optimizer with cost reduction and LLM integration
+license: mit
 ---
 
-# Welcome to Streamlit!
+# AI Prompt Optimizer
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+An advanced Streamlit web application that helps reduce the cost of using large language models (LLMs) by intelligently optimizing prompts. The app shortens prompts by removing filler words, simplifying phrases, and using sophisticated linguistic techniques, thereby reducing the number of tokens sent to APIs.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Features
+
+- **Advanced Prompt Optimization**: Rule-based optimization using spaCy and linguistic techniques
+- **LLM-based Optimization**: 8 specialized personas for context-aware optimization
+- **Real-time Cost Analysis**: Accurate token counting and cost savings calculation
+- **Multi-Model Support**: GPT-4, GPT-5, Claude, LLaMA 2, and custom models
+- **Professional UI**: Modern, gradient-based interface with responsive design
+- **Tavily Search Integration**: Enhanced prompts with real-time web information
+- **MCP Server Support**: Model Context Protocol integration for advanced workflows
+
+## Technologies Used
+
+- **Streamlit**: Modern web interface
+- **spaCy**: Natural language processing
+- **tiktoken**: Accurate token counting
+- **LangChain**: LLM integration and metadata tracking
+- **Tavily**: Web search API integration
+
+## Usage
+
+1. Enter your prompt text
+2. Choose optimization method (Local or LLM-based)
+3. Select model and persona (for LLM optimization)
+4. Click "Optimize" to see results and cost savings
+
+Perfect for developers, content creators, and AI enthusiasts looking to reduce LLM costs while maintaining prompt effectiveness.
+
+## Deployment on Hugging Face Spaces
+
+This app is ready to deploy on Hugging Face Spaces. To deploy:
+
+1. **Fork this repository** or upload the files to your Hugging Face Space
+2. **Set up environment variables** in your Space settings:
+   - `AIMLAPI_API_KEY`: Get from [AIMLAPI](https://aimlapi.com) (required for LLM-based optimization)
+   - `TAVILY_API_KEY`: Get from [Tavily](https://tavily.com) (required for agent functionality)
+3. **Configure your Space**:
+   - SDK: Docker
+   - App port: 8501
+   - Hardware: CPU basic (recommended)
+
+The app will automatically detect missing API keys and allow users to enter them manually if needed.
+
+## Local Development
+
+1. Clone the repository
+2. Install dependencies: `pip install -r requirements.txt`
+3. Copy `.env.example` to `.env` and add your API keys
+4. Run: `streamlit run src/app.py`

requirements.txt

@@ -1,3 +1,138 @@
-altair
-pandas
-streamlit
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.10.0
+attrs==25.3.0
+authlib==1.6.2
+blinker==1.9.0
+blis==0.7.11
+cachetools==6.1.0
+catalogue==2.0.10
+certifi==2025.8.3
+cffi==1.17.1
+charset-normalizer==3.4.3
+click==8.2.1
+cloudpathlib==0.21.1
+confection==0.1.5
+cryptography==45.0.6
+cyclopts==3.22.5
+cymem==2.0.11
+distro==1.9.0
+dnspython==2.7.0
+docstring-parser==0.17.0
+docutils==0.22
+email-validator==2.2.0
+en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.0/en_core_web_sm-3.7.0.tar.gz
+exceptiongroup==1.3.0
+fastmcp==2.11.3
+frozenlist==1.7.0
+gitdb==4.0.12
+gitpython==3.1.45
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.1
+idna==3.10
+isodate==0.7.2
+jinja2==3.1.6
+jiter==0.10.0
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.25.1
+jsonschema-path==0.3.4
+jsonschema-specifications==2025.4.1
+langchain==0.3.27
+langchain-core==0.3.74
+langchain-openai==0.3.31
+langchain-tavily==0.2.11
+langchain-text-splitters==0.3.9
+langcodes==3.5.0
+langgraph==0.6.6
+langgraph-checkpoint==2.1.1
+langgraph-prebuilt==0.6.4
+langgraph-sdk==0.2.3
+langsmith==0.4.16
+language-data==1.3.0
+lazy-object-proxy==1.12.0
+lemminflect==0.2.3
+marisa-trie==1.3.0
+markdown-it-py==4.0.0
+markupsafe==3.0.2
+mcp==1.13.1
+mdurl==0.1.2
+more-itertools==10.7.0
+multidict==6.6.4
+murmurhash==1.0.13
+narwhals==2.1.2
+numpy==1.26.4
+openai==1.101.0
+openapi-core==0.19.5
+openapi-pydantic==0.5.1
+openapi-schema-validator==0.6.3
+openapi-spec-validator==0.7.2
+orjson==3.11.2
+ormsgpack==1.10.0
+packaging==25.0
+pandas==2.3.2
+parse==1.20.2
+pathable==0.4.4
+pillow==11.3.0
+preshed==3.0.10
+propcache==0.3.2
+protobuf==6.32.0
+pyarrow==21.0.0
+pycparser==2.22
+pydantic==2.11.7
+pydantic-core==2.33.2
+pydantic-settings==2.10.1
+pydeck==0.9.1
+pygments==2.19.2
+pyperclip==1.9.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+python-multipart==0.0.20
+pytz==2025.2
+pyyaml==6.0.2
+referencing==0.36.2
+regex==2025.7.34
+requests==2.32.5
+requests-toolbelt==1.0.0
+rfc3339-validator==0.1.4
+rich==14.1.0
+rich-rst==1.3.1
+rpds-py==0.27.0
+setuptools==80.9.0
+shellingham==1.5.4
+six==1.17.0
+smart-open==7.3.0.post1
+smmap==5.0.2
+sniffio==1.3.1
+spacy==3.7.5
+spacy-legacy==3.0.12
+spacy-loggers==1.0.5
+sqlalchemy==2.0.43
+srsly==2.5.1
+sse-starlette==3.0.2
+starlette==0.47.2
+streamlit==1.48.1
+tenacity==9.1.2
+thinc==8.2.5
+tiktoken==0.11.0
+toml==0.10.2
+tornado==6.5.2
+tqdm==4.67.1
+typer==0.16.1
+typing-extensions==4.14.1
+typing-inspection==0.4.1
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+wasabi==1.1.3
+weasel==0.4.1
+werkzeug==3.1.1
+wrapt==1.17.3
+xxhash==3.5.0
+yarl==1.20.1
+zstandard==0.24.0

src/.github/workflows/gemini-cli.yml

@@ -0,0 +1,315 @@
+name: '💬 Gemini CLI'
+
+on:
+  pull_request_review_comment:
+    types:
+      - 'created'
+  pull_request_review:
+    types:
+      - 'submitted'
+  issue_comment:
+    types:
+      - 'created'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.event.issue.number }}'
+  cancel-in-progress: |-
+    ${{ github.event.sender.type == 'User' && ( github.event.issue.author_association == 'OWNER' || github.event.issue.author_association == 'MEMBER' || github.event.issue.author_association == 'COLLABORATOR') }}
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'write'
+  id-token: 'write'
+  pull-requests: 'write'
+  issues: 'write'
+
+jobs:
+  gemini-cli:
+    # This condition seeks to ensure the action is only run when it is triggered by a trusted user.
+    # For private repos, users who have access to the repo are considered trusted.
+    # For public repos, users who members, owners, or collaborators are considered trusted.
+    if: |-
+      github.event_name == 'workflow_dispatch' ||
+      (
+        github.event_name == 'issues' && github.event.action == 'opened' &&
+        contains(github.event.issue.body, '@gemini-cli') &&
+        !contains(github.event.issue.body, '@gemini-cli /review') &&
+        !contains(github.event.issue.body, '@gemini-cli /triage') &&
+        (
+          github.event.repository.private == true ||
+          contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.issue.author_association)
+        )
+      ) ||
+      (
+        (
+          github.event_name == 'issue_comment' ||
+          github.event_name == 'pull_request_review_comment'
+        ) &&
+        contains(github.event.comment.body, '@gemini-cli') &&
+        !contains(github.event.comment.body, '@gemini-cli /review') &&
+        !contains(github.event.comment.body, '@gemini-cli /triage') &&
+        (
+          github.event.repository.private == true ||
+          contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.comment.author_association)
+        )
+      ) ||
+      (
+        github.event_name == 'pull_request_review' &&
+        contains(github.event.review.body, '@gemini-cli') &&
+        !contains(github.event.review.body, '@gemini-cli /review') &&
+        !contains(github.event.review.body, '@gemini-cli /triage') &&
+        (
+          github.event.repository.private == true ||
+          contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.review.author_association)
+        )
+      )
+    timeout-minutes: 10
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        if: |-
+          ${{ vars.APP_ID }}
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e' # ratchet:actions/create-github-app-token@v2
+        with:
+          app-id: '${{ vars.APP_ID }}'
+          private-key: '${{ secrets.APP_PRIVATE_KEY }}'
+
+      - name: 'Get context from event'
+        id: 'get_context'
+        env:
+          EVENT_NAME: '${{ github.event_name }}'
+          EVENT_PAYLOAD: '${{ toJSON(github.event) }}'
+        run: |-
+          set -euo pipefail
+
+          USER_REQUEST=""
+          ISSUE_NUMBER=""
+          IS_PR="false"
+
+          if [[ "${EVENT_NAME}" == "issues" ]]; then
+            USER_REQUEST=$(echo "${EVENT_PAYLOAD}" | jq -r .issue.body)
+            ISSUE_NUMBER=$(echo "${EVENT_PAYLOAD}" | jq -r .issue.number)
+          elif [[ "${EVENT_NAME}" == "issue_comment" ]]; then
+            USER_REQUEST=$(echo "${EVENT_PAYLOAD}" | jq -r .comment.body)
+            ISSUE_NUMBER=$(echo "${EVENT_PAYLOAD}" | jq -r .issue.number)
+            if [[ $(echo "${EVENT_PAYLOAD}" | jq -r .issue.pull_request) != "null" ]]; then
+              IS_PR="true"
+            fi
+          elif [[ "${EVENT_NAME}" == "pull_request_review" ]]; then
+            USER_REQUEST=$(echo "${EVENT_PAYLOAD}" | jq -r .review.body)
+            ISSUE_NUMBER=$(echo "${EVENT_PAYLOAD}" | jq -r .pull_request.number)
+            IS_PR="true"
+          elif [[ "${EVENT_NAME}" == "pull_request_review_comment" ]]; then
+            USER_REQUEST=$(echo "${EVENT_PAYLOAD}" | jq -r .comment.body)
+            ISSUE_NUMBER=$(echo "${EVENT_PAYLOAD}" | jq -r .pull_request.number)
+            IS_PR="true"
+          fi
+
+          # Clean up user request
+          USER_REQUEST=$(echo "${USER_REQUEST}" | sed 's/.*@gemini-cli//' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+          {
+            echo "user_request=${USER_REQUEST}"
+            echo "issue_number=${ISSUE_NUMBER}"
+            echo "is_pr=${IS_PR}"
+          } >> "${GITHUB_OUTPUT}"
+
+      - name: 'Set up git user for commits'
+        run: |-
+          git config --global user.name 'gemini-cli[bot]'
+          git config --global user.email 'gemini-cli[bot]@users.noreply.github.com'
+
+      - name: 'Checkout PR branch'
+        if: |-
+          ${{  steps.get_context.outputs.is_pr == 'true' }}
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683' # ratchet:actions/checkout@v4
+        with:
+          token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          repository: '${{ github.repository }}'
+          ref: 'refs/pull/${{ steps.get_context.outputs.issue_number }}/head'
+          fetch-depth: 0
+
+      - name: 'Checkout main branch'
+        if: |-
+          ${{  steps.get_context.outputs.is_pr == 'false' }}
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683' # ratchet:actions/checkout@v4
+        with:
+          token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          repository: '${{ github.repository }}'
+          fetch-depth: 0
+
+      - name: 'Acknowledge request'
+        env:
+          GITHUB_ACTOR: '${{ github.actor }}'
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          ISSUE_NUMBER: '${{ steps.get_context.outputs.issue_number }}'
+          REPOSITORY: '${{ github.repository }}'
+          REQUEST_TYPE: '${{ steps.get_context.outputs.request_type }}'
+        run: |-
+          set -euo pipefail
+          MESSAGE="@${GITHUB_ACTOR} I've received your request and I'm working on it now! 🤖"
+          if [[ -n "${MESSAGE}" ]]; then
+            gh issue comment "${ISSUE_NUMBER}" \
+              --body "${MESSAGE}" \
+              --repo "${REPOSITORY}"
+          fi
+
+      - name: 'Get description'
+        id: 'get_description'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          IS_PR: '${{ steps.get_context.outputs.is_pr }}'
+          ISSUE_NUMBER: '${{ steps.get_context.outputs.issue_number }}'
+        run: |-
+          set -euo pipefail
+          if [[ "${IS_PR}" == "true" ]]; then
+            DESCRIPTION=$(gh pr view "${ISSUE_NUMBER}" --json body --template '{{.body}}')
+          else
+            DESCRIPTION=$(gh issue view "${ISSUE_NUMBER}" --json body --template '{{.body}}')
+          fi
+          {
+            echo "description<<EOF"
+            echo "${DESCRIPTION}"
+            echo "EOF"
+          } >> "${GITHUB_OUTPUT}"
+
+      - name: 'Get comments'
+        id: 'get_comments'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          IS_PR: '${{ steps.get_context.outputs.is_pr }}'
+          ISSUE_NUMBER: '${{ steps.get_context.outputs.issue_number }}'
+        run: |-
+          set -euo pipefail
+          if [[ "${IS_PR}" == "true" ]]; then
+            COMMENTS=$(gh pr view "${ISSUE_NUMBER}" --json comments --template '{{range .comments}}{{.author.login}}: {{.body}}{{"\n"}}{{end}}')
+          else
+            COMMENTS=$(gh issue view "${ISSUE_NUMBER}" --json comments --template '{{range .comments}}{{.author.login}}: {{.body}}{{"\n"}}{{end}}')
+          fi
+          {
+            echo "comments<<EOF"
+            echo "${COMMENTS}"
+            echo "EOF"
+          } >> "${GITHUB_OUTPUT}"
+
+      - name: 'Run Gemini'
+        id: 'run_gemini'
+        uses: 'google-github-actions/run-gemini-cli@v0'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          REPOSITORY: '${{ github.repository }}'
+          USER_REQUEST: '${{ steps.get_context.outputs.user_request }}'
+          ISSUE_NUMBER: '${{ steps.get_context.outputs.issue_number }}'
+          IS_PR: '${{ steps.get_context.outputs.is_pr }}'
+        with:
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "debug": ${{ fromJSON(env.DEBUG || env.ACTIONS_STEP_DEBUG || false) }},
+              "maxSessionTurns": 50,
+              "telemetry": {
+                "enabled": false,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+
+            You are a helpful AI assistant invoked via a CLI interface in a GitHub workflow. You have access to tools to interact with the repository and respond to the user.
+
+            ## Context
+
+            - **Repository**: `${{ github.repository }}`
+            - **Triggering Event**: `${{ github.event_name }}`
+            - **Issue/PR Number**: `${{ steps.get_context.outputs.issue_number }}`
+            - **Is this a PR?**: `${{ steps.get_context.outputs.is_pr }}`
+            - **Issue/PR Description**:
+            `${{ steps.get_description.outputs.description }}`
+            - **Comments**:
+            `${{ steps.get_comments.outputs.comments }}`
+
+            ## User Request
+
+            The user has sent the following request:
+            `${{ steps.get_context.outputs.user_request }}`
+
+            ## How to Respond to Issues, PR Comments, and Questions
+
+            This workflow supports three main scenarios:
+
+            1. **Creating a Fix for an Issue**
+               - Carefully read the user request and the related issue or PR description.
+               - Use available tools to gather all relevant context (e.g., `gh issue view`, `gh pr view`, `gh pr diff`, `cat`, `head`, `tail`).
+               - Identify the root cause of the problem before proceeding.
+               - **Show and maintain a plan as a checklist**:
+                 - At the very beginning, outline the steps needed to resolve the issue or address the request and post them as a checklist comment on the issue or PR (use GitHub markdown checkboxes: `- [ ] Task`).
+                 - Example:
+                   ```
+                   ### Plan
+                   - [ ] Investigate the root cause
+                   - [ ] Implement the fix in `file.py`
+                   - [ ] Add/modify tests
+                   - [ ] Update documentation
+                   - [ ] Verify the fix and close the issue
+                   ```
+                 - Use: `gh pr comment "${ISSUE_NUMBER}" --body "<plan>"` or `gh issue comment "${ISSUE_NUMBER}" --body "<plan>"` to post the initial plan.
+                 - As you make progress, keep the checklist visible and up to date by editing the same comment (check off completed tasks with `- [x]`).
+                   - To update the checklist:
+                     1. Find the comment ID for the checklist (use `gh pr comment list "${ISSUE_NUMBER}"` or `gh issue comment list "${ISSUE_NUMBER}"`).
+                     2. Edit the comment with the updated checklist:
+                        - For PRs: `gh pr comment --edit <comment-id> --body "<updated plan>"`
+                        - For Issues: `gh issue comment --edit <comment-id> --body "<updated plan>"`
+                     3. The checklist should only be maintained as a comment on the issue or PR. Do not track or update the checklist in code files.
+               - If the fix requires code changes, determine which files and lines are affected. If clarification is needed, note any questions for the user.
+               - Make the necessary code or documentation changes using the available tools (e.g., `write_file`). Ensure all changes follow project conventions and best practices. Reference all shell variables as `"${VAR}"` (with quotes and braces) to prevent errors.
+               - Run any relevant tests or checks to verify the fix works as intended. If possible, provide evidence (test output, screenshots, etc.) that the issue is resolved.
+               - **Branching and Committing**:
+                 - **NEVER commit directly to the `main` branch.**
+                 - If you are working on a **pull request** (`IS_PR` is `true`), the correct branch is already checked out. Simply commit and push to it.
+                   - `git add .`
+                   - `git commit -m "feat: <describe the change>"`
+                   - `git push`
+                 - If you are working on an **issue** (`IS_PR` is `false`), create a new branch for your changes. A good branch name would be `issue/${ISSUE_NUMBER}/<short-description>`.
+                   - `git checkout -b issue/${ISSUE_NUMBER}/my-fix`
+                   - `git add .`
+                   - `git commit -m "feat: <describe the fix>"`
+                   - `git push origin issue/${ISSUE_NUMBER}/my-fix`
+                   - After pushing, you can create a pull request: `gh pr create --title "Fixes #${ISSUE_NUMBER}: <short title>" --body "This PR addresses issue #${ISSUE_NUMBER}."`
+               - Summarize what was changed and why in a markdown file: `write_file("response.md", "<your response here>")`
+               - Post the response as a comment:
+                 - For PRs: `gh pr comment "${ISSUE_NUMBER}" --body-file response.md`
+                 - For Issues: `gh issue comment "${ISSUE_NUMBER}" --body-file response.md`
+
+            2. **Addressing Comments on a Pull Request**
+               - Read the specific comment and the context of the PR.
+               - Use tools like `gh pr view`, `gh pr diff`, and `cat` to understand the code and discussion.
+               - If the comment requests a change or clarification, follow the same process as for fixing an issue: create a checklist plan, implement, test, and commit any required changes, updating the checklist as you go.
+               - **Committing Changes**: The correct PR branch is already checked out. Simply add, commit, and push your changes.
+                 - `git add .`
+                 - `git commit -m "fix: address review comments"`
+                 - `git push`
+               - If the comment is a question, answer it directly and clearly, referencing code or documentation as needed.
+               - Document your response in `response.md` and post it as a PR comment: `gh pr comment "${ISSUE_NUMBER}" --body-file response.md`
+
+            3. **Answering Any Question on an Issue**
+               - Read the question and the full issue context using `gh issue view` and related tools.
+               - Research or analyze the codebase as needed to provide an accurate answer.
+               - If the question requires code or documentation changes, follow the fix process above, including creating and updating a checklist plan and **creating a new branch for your changes as described in section 1.**
+               - Write a clear, concise answer in `response.md` and post it as an issue comment: `gh issue comment "${ISSUE_NUMBER}" --body-file response.md`
+
+            ## Guidelines
+
+            - **Be concise and actionable.** Focus on solving the user's problem efficiently.
+            - **Always commit and push your changes if you modify code or documentation.**
+            - **If you are unsure about the fix or answer, explain your reasoning and ask clarifying questions.**
+            - **Follow project conventions and best practices.**

src/.github/workflows/gemini-issue-automated-triage.yml

@@ -0,0 +1,191 @@
+name: '🏷️ Gemini Automated Issue Triage'
+
+on:
+  issues:
+    types:
+      - 'opened'
+      - 'reopened'
+  issue_comment:
+    types:
+      - 'created'
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: 'issue number to triage'
+        required: true
+        type: 'number'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.event.issue.number }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+  issues: 'write'
+  statuses: 'write'
+
+jobs:
+  triage-issue:
+    if: |-
+      github.event_name == 'issues' ||
+      github.event_name == 'workflow_dispatch' ||
+      (
+        github.event_name == 'issue_comment' &&
+        contains(github.event.comment.body, '@gemini-cli /triage') &&
+        contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.comment.author_association)
+      )
+    timeout-minutes: 5
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Checkout repository'
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683' # ratchet:actions/checkout@v4
+
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        if: |-
+          ${{ vars.APP_ID }}
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e' # ratchet:actions/create-github-app-token@v2
+        with:
+          app-id: '${{ vars.APP_ID }}'
+          private-key: '${{ secrets.APP_PRIVATE_KEY }}'
+
+      - name: 'Get Repository Labels'
+        id: 'get_labels'
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          script: |-
+            const { data: labels } = await github.rest.issues.listLabelsForRepo({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            });
+            const labelNames = labels.map(label => label.name);
+            core.setOutput('available_labels', labelNames.join(','));
+            core.info(`Found ${labelNames.length} labels: ${labelNames.join(', ')}`);
+            return labelNames;
+
+      - name: 'Run Gemini Issue Analysis'
+        uses: 'google-github-actions/run-gemini-cli@v0'
+        id: 'gemini_issue_analysis'
+        env:
+          GITHUB_TOKEN: '' # Do not pass any auth token here since this runs on untrusted inputs
+          ISSUE_TITLE: '${{ github.event.issue.title }}'
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+          AVAILABLE_LABELS: '${{ steps.get_labels.outputs.available_labels }}'
+        with:
+          gemini_cli_version: '${{ vars.GEMINI_CLI_VERSION }}'
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "debug": ${{ fromJSON(env.DEBUG || env.ACTIONS_STEP_DEBUG || false) }},
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command(echo)"
+              ],
+              "telemetry": {
+                "enabled": false,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+
+            You are an issue triage assistant. Analyze the current GitHub issue
+            and identify the most appropriate existing labels. Use the available
+            tools to gather information; do not ask for information to be
+            provided.
+
+            ## Steps
+
+            1. Review the available labels in the environment variable: "${AVAILABLE_LABELS}".
+            2. Review the issue title and body provided in the environment
+               variables: "${ISSUE_TITLE}" and "${ISSUE_BODY}".
+            3. Classify the issue by the appropriate labels from the available labels.
+            4. Output the appropriate labels for this issue in JSON format with explanation, for example:
+               ```
+               {"labels_to_set": ["kind/bug", "priority/p0"], "explanation": "This is a critical bug report affecting main functionality"}
+               ```
+            5. If the issue cannot be classified using the available labels, output:
+               ```
+               {"labels_to_set": [], "explanation": "Unable to classify this issue with available labels"}
+               ```
+
+            ## Guidelines
+
+            - Only use labels that already exist in the repository
+            - Assign all applicable labels based on the issue content
+            - Reference all shell variables as "${VAR}" (with quotes and braces)
+            - Output only valid JSON format
+            - Do not include any explanation or additional text, just the JSON
+
+      - name: 'Apply Labels to Issue'
+        if: |-
+          ${{ steps.gemini_issue_analysis.outputs.summary != '' }}
+        env:
+          REPOSITORY: '${{ github.repository }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          LABELS_OUTPUT: '${{ steps.gemini_issue_analysis.outputs.summary }}'
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          script: |-
+            // Strip code block markers if present
+            const rawLabels = process.env.LABELS_OUTPUT;
+            core.info(`Raw labels JSON: ${rawLabels}`);
+            let parsedLabels;
+            try {
+              const trimmedLabels = rawLabels.replace(/^```(?:json)?\s*/, '').replace(/\s*```$/, '').trim();
+              parsedLabels = JSON.parse(trimmedLabels);
+              core.info(`Parsed labels JSON: ${JSON.stringify(parsedLabels)}`);
+            } catch (err) {
+              core.setFailed(`Failed to parse labels JSON from Gemini output: ${err.message}\nRaw output: ${rawLabels}`);
+              return;
+            }
+
+            const issueNumber = parseInt(process.env.ISSUE_NUMBER);
+
+            // Set labels based on triage result
+            if (parsedLabels.labels_to_set && parsedLabels.labels_to_set.length > 0) {
+              await github.rest.issues.setLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                labels: parsedLabels.labels_to_set
+              });
+              const explanation = parsedLabels.explanation ? ` - ${parsedLabels.explanation}` : '';
+              core.info(`Successfully set labels for #${issueNumber}: ${parsedLabels.labels_to_set.join(', ')}${explanation}`);
+            } else {
+              // If no labels to set, leave the issue as is
+              const explanation = parsedLabels.explanation ? ` - ${parsedLabels.explanation}` : '';
+              core.info(`No labels to set for #${issueNumber}, leaving as is${explanation}`);
+            }
+
+      - name: 'Post Issue Analysis Failure Comment'
+        if: |-
+          ${{ failure() && steps.gemini_issue_analysis.outcome == 'failure' }}
+        env:
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          RUN_URL: '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          script: |-
+            github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: parseInt(process.env.ISSUE_NUMBER),
+              body: 'There is a problem with the Gemini CLI issue triaging. Please check the [action logs](${process.env.RUN_URL}) for details.'
+            })

src/.github/workflows/gemini-issue-scheduled-triage.yml

@@ -0,0 +1,193 @@
+name: '📋 Gemini Scheduled Issue Triage'
+
+on:
+  schedule:
+    - cron: '0 * * * *' # Runs every hour
+  workflow_dispatch:
+
+concurrency:
+  group: '${{ github.workflow }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+  issues: 'write'
+  statuses: 'write'
+
+jobs:
+  triage-issues:
+    timeout-minutes: 5
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Checkout repository'
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683' # ratchet:actions/checkout@v4
+
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        if: |-
+          ${{ vars.APP_ID }}
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e' # ratchet:actions/create-github-app-token@v2
+        with:
+          app-id: '${{ vars.APP_ID }}'
+          private-key: '${{ secrets.APP_PRIVATE_KEY }}'
+
+      - name: 'Find untriaged issues'
+        id: 'find_issues'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          GITHUB_REPOSITORY: '${{ github.repository }}'
+          GITHUB_OUTPUT: '${{ github.output }}'
+        run: |-
+          set -euo pipefail
+
+          echo '🔍 Finding issues without labels...'
+          NO_LABEL_ISSUES="$(gh issue list --repo "${GITHUB_REPOSITORY}" \
+            --search 'is:open is:issue no:label' --json number,title,body)"
+
+          echo '🏷️ Finding issues that need triage...'
+          NEED_TRIAGE_ISSUES="$(gh issue list --repo "${GITHUB_REPOSITORY}" \
+            --search 'is:open is:issue label:"status/needs-triage"' --json number,title,body)"
+
+          echo '🔄 Merging and deduplicating issues...'
+          ISSUES="$(echo "${NO_LABEL_ISSUES}" "${NEED_TRIAGE_ISSUES}" | jq -c -s 'add | unique_by(.number)')"
+
+          echo '📝 Setting output for GitHub Actions...'
+          echo "issues_to_triage=${ISSUES}" >> "${GITHUB_OUTPUT}"
+
+          ISSUE_COUNT="$(echo "${ISSUES}" | jq 'length')"
+          echo "✅ Found ${ISSUE_COUNT} issues to triage! 🎯"
+
+      - name: 'Get Repository Labels'
+        id: 'get_labels'
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          script: |-
+            const { data: labels } = await github.rest.issues.listLabelsForRepo({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            });
+            const labelNames = labels.map(label => label.name);
+            core.setOutput('available_labels', labelNames.join(','));
+            core.info(`Found ${labelNames.length} labels: ${labelNames.join(', ')}`);
+            return labelNames;
+
+      - name: 'Run Gemini Issue Analysis'
+        if: |-
+          ${{ steps.find_issues.outputs.issues_to_triage != '[]' }}
+        uses: 'google-github-actions/run-gemini-cli@v0'
+        id: 'gemini_issue_analysis'
+        env:
+          GITHUB_TOKEN: '' # Do not pass any auth token here since this runs on untrusted inputs
+          ISSUES_TO_TRIAGE: '${{ steps.find_issues.outputs.issues_to_triage }}'
+          REPOSITORY: '${{ github.repository }}'
+          AVAILABLE_LABELS: '${{ steps.get_labels.outputs.available_labels }}'
+        with:
+          gemini_cli_version: '${{ vars.GEMINI_CLI_VERSION }}'
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "debug": ${{ fromJSON(env.DEBUG || env.ACTIONS_STEP_DEBUG || false) }},
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command(echo)"
+              ],
+              "telemetry": {
+                "enabled": false,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+
+            You are an issue triage assistant. Analyze the GitHub issues and
+            identify the most appropriate existing labels to apply.
+
+            ## Steps
+
+            1. Review the available labels in the environment variable: "${AVAILABLE_LABELS}".
+            2. Review the issues in the environment variable: "${ISSUES_TO_TRIAGE}".
+            3. For each issue, classify it by the appropriate labels from the available labels.
+            4. Output a JSON array of objects, each containing the issue number,
+               the labels to set, and a brief explanation. For example:
+               ```
+               [
+                 {
+                   "issue_number": 123,
+                   "labels_to_set": ["kind/bug", "priority/p2"],
+                   "explanation": "This is a bug report with high priority based on the error description"
+                 },
+                 {
+                   "issue_number": 456,
+                   "labels_to_set": ["kind/enhancement"],
+                   "explanation": "This is a feature request for improving the UI"
+                 }
+               ]
+               ```
+            5. If an issue cannot be classified, do not include it in the output array.
+
+            ## Guidelines
+
+            - Only use labels that already exist in the repository
+            - Assign all applicable labels based on the issue content
+            - Reference all shell variables as "${VAR}" (with quotes and braces)
+            - Output only valid JSON format
+            - Do not include any explanation or additional text, just the JSON
+
+      - name: 'Apply Labels to Issues'
+        if: |-
+          ${{ steps.gemini_issue_analysis.outcome == 'success' &&
+              steps.gemini_issue_analysis.outputs.summary != '[]' }}
+        env:
+          REPOSITORY: '${{ github.repository }}'
+          LABELS_OUTPUT: '${{ steps.gemini_issue_analysis.outputs.summary }}'
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          script: |-
+            // Strip code block markers if present
+            const rawLabels = process.env.LABELS_OUTPUT;
+            core.info(`Raw labels JSON: ${rawLabels}`);
+            let parsedLabels;
+            try {
+              const trimmedLabels = rawLabels.replace(/^```(?:json)?\s*/, '').replace(/\s*```$/, '').trim();
+              parsedLabels = JSON.parse(trimmedLabels);
+              core.info(`Parsed labels JSON: ${JSON.stringify(parsedLabels)}`);
+            } catch (err) {
+              core.setFailed(`Failed to parse labels JSON from Gemini output: ${err.message}\nRaw output: ${rawLabels}`);
+              return;
+            }
+
+            for (const entry of parsedLabels) {
+              const issueNumber = entry.issue_number;
+              if (!issueNumber) {
+                core.info(`Skipping entry with no issue number: ${JSON.stringify(entry)}`);
+                continue;
+              }
+
+              // Set labels based on triage result
+              if (entry.labels_to_set && entry.labels_to_set.length > 0) {
+                await github.rest.issues.setLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issueNumber,
+                  labels: entry.labels_to_set
+                });
+                const explanation = entry.explanation ? ` - ${entry.explanation}` : '';
+                core.info(`Successfully set labels for #${issueNumber}: ${entry.labels_to_set.join(', ')}${explanation}`);
+              } else {
+                // If no labels to set, leave the issue as is
+                core.info(`No labels to set for #${issueNumber}, leaving as is`);
+              }
+            }

src/.github/workflows/gemini-pr-review.yml

@@ -0,0 +1,468 @@
+name: '🧐 Gemini Pull Request Review'
+
+on:
+  pull_request:
+    types:
+      - 'opened'
+      - 'reopened'
+  issue_comment:
+    types:
+      - 'created'
+  pull_request_review_comment:
+    types:
+      - 'created'
+  pull_request_review:
+    types:
+      - 'submitted'
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: 'PR number to review'
+        required: true
+        type: 'number'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+  issues: 'write'
+  pull-requests: 'write'
+  statuses: 'write'
+
+jobs:
+  review-pr:
+    # This condition seeks to ensure the action is only run when it is triggered by a trusted user.
+    # For private repos, users who have access to the repo are considered trusted.
+    # For public repos, users who members, owners, or collaborators are considered trusted.
+    if: |-
+      github.event_name == 'workflow_dispatch' ||
+      (
+        github.event_name == 'pull_request' &&
+        (
+          github.event.repository.private == true ||
+          contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.pull_request.author_association)
+        )
+      ) ||
+      (
+        (
+          (
+            github.event_name == 'issue_comment' &&
+            github.event.issue.pull_request
+          ) ||
+          github.event_name == 'pull_request_review_comment'
+        ) &&
+        contains(github.event.comment.body, '@gemini-cli /review') &&
+        (
+          github.event.repository.private == true ||
+          contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.comment.author_association)
+        )
+      ) ||
+      (
+        github.event_name == 'pull_request_review' &&
+        contains(github.event.review.body, '@gemini-cli /review') &&
+        (
+          github.event.repository.private == true ||
+          contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.review.author_association)
+        )
+      )
+    timeout-minutes: 5
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Checkout PR code'
+        uses: 'actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683' # ratchet:actions/checkout@v4
+
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        if: |-
+          ${{ vars.APP_ID }}
+        uses: 'actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e' # ratchet:actions/create-github-app-token@v2
+        with:
+          app-id: '${{ vars.APP_ID }}'
+          private-key: '${{ secrets.APP_PRIVATE_KEY }}'
+
+      - name: 'Get PR details (pull_request & workflow_dispatch)'
+        id: 'get_pr'
+        if: |-
+          ${{ github.event_name == 'pull_request' || github.event_name == 'workflow_dispatch' }}
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          EVENT_NAME: '${{ github.event_name }}'
+          WORKFLOW_PR_NUMBER: '${{ github.event.inputs.pr_number }}'
+          PULL_REQUEST_NUMBER: '${{ github.event.pull_request.number }}'
+        run: |-
+          set -euo pipefail
+
+          if [[ "${EVENT_NAME}" = "workflow_dispatch" ]]; then
+            PR_NUMBER="${WORKFLOW_PR_NUMBER}"
+          else
+            PR_NUMBER="${PULL_REQUEST_NUMBER}"
+          fi
+
+          echo "pr_number=${PR_NUMBER}" >> "${GITHUB_OUTPUT}"
+
+          # Get PR details
+          PR_DATA="$(gh pr view "${PR_NUMBER}" --json title,body,additions,deletions,changedFiles,baseRefName,headRefName)"
+          echo "pr_data=${PR_DATA}" >> "${GITHUB_OUTPUT}"
+
+          # Get file changes
+          CHANGED_FILES="$(gh pr diff "${PR_NUMBER}" --name-only)"
+          {
+            echo "changed_files<<EOF"
+            echo "${CHANGED_FILES}"
+            echo "EOF"
+          } >> "${GITHUB_OUTPUT}"
+
+
+      - name: 'Get PR details (issue_comment & reviews)'
+        id: 'get_pr_comment'
+        if: |-
+          ${{ github.event_name == 'issue_comment' || github.event_name == 'pull_request_review' || github.event_name == 'pull_request_review_comment' }}
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          COMMENT_BODY: '${{ github.event.comment.body || github.event.review.body }}'
+          PR_NUMBER: '${{ github.event.issue.number || github.event.pull_request.number }}'
+        run: |-
+          set -euo pipefail
+
+          echo "pr_number=${PR_NUMBER}" >> "${GITHUB_OUTPUT}"
+
+          # Extract additional instructions from comment
+          ADDITIONAL_INSTRUCTIONS="$(
+            echo "${COMMENT_BODY}" | sed 's/.*@gemini-cli \/review//' | xargs
+          )"
+          echo "additional_instructions=${ADDITIONAL_INSTRUCTIONS}" >> "${GITHUB_OUTPUT}"
+
+          # Get PR details
+          PR_DATA="$(gh pr view "${PR_NUMBER}" --json title,body,additions,deletions,changedFiles,baseRefName,headRefName)"
+          echo "pr_data=${PR_DATA}" >> "${GITHUB_OUTPUT}"
+
+          # Get file changes
+          CHANGED_FILES="$(gh pr diff "${PR_NUMBER}" --name-only)"
+          {
+            echo "changed_files<<EOF"
+            echo "${CHANGED_FILES}"
+            echo "EOF"
+          } >> "${GITHUB_OUTPUT}"
+
+      - name: 'Run Gemini PR Review'
+        uses: 'google-github-actions/run-gemini-cli@v0'
+        id: 'gemini_pr_review'
+        env:
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          PR_NUMBER: '${{ steps.get_pr.outputs.pr_number || steps.get_pr_comment.outputs.pr_number }}'
+          PR_DATA: '${{ steps.get_pr.outputs.pr_data || steps.get_pr_comment.outputs.pr_data }}'
+          CHANGED_FILES: '${{ steps.get_pr.outputs.changed_files || steps.get_pr_comment.outputs.changed_files }}'
+          ADDITIONAL_INSTRUCTIONS: '${{ steps.get_pr.outputs.additional_instructions || steps.get_pr_comment.outputs.additional_instructions }}'
+          REPOSITORY: '${{ github.repository }}'
+        with:
+          gemini_cli_version: '${{ vars.GEMINI_CLI_VERSION }}'
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "debug": ${{ fromJSON(env.DEBUG || env.ACTIONS_STEP_DEBUG || false) }},
+              "maxSessionTurns": 20,
+              "mcpServers": {
+                "github": {
+                  "command": "docker",
+                  "args": [
+                    "run",
+                    "-i",
+                    "--rm",
+                    "-e",
+                    "GITHUB_PERSONAL_ACCESS_TOKEN",
+                    "ghcr.io/github/github-mcp-server"
+                  ],
+                  "includeTools": [
+                    "create_pending_pull_request_review",
+                    "add_comment_to_pending_review",
+                    "submit_pending_pull_request_review"
+                  ],
+                  "env": {
+                    "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
+                  }
+                }
+              },
+              "coreTools": [
+                "run_shell_command(echo)",
+                "run_shell_command(gh pr view)",
+                "run_shell_command(gh pr diff)",
+                "run_shell_command(cat)",
+                "run_shell_command(head)",
+                "run_shell_command(tail)",
+                "run_shell_command(grep)"
+              ],
+              "telemetry": {
+                "enabled": false,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+
+            You are an expert code reviewer. You have access to tools to gather
+            PR information and perform the review on GitHub. Use the available tools to
+            gather information; do not ask for information to be provided.
+
+            ## Requirements
+            1. All feedback must be left on GitHub.
+            2. Any output that is not left in GitHub will not be seen.
+
+            ## Steps
+
+            Start by running these commands to gather the required data:
+            1. Run: echo "${REPOSITORY}" to get the github repository in <OWNER>/<REPO> format
+            2. Run: echo "${PR_DATA}" to get PR details (JSON format)
+            3. Run: echo "${CHANGED_FILES}" to get the list of changed files
+            4. Run: echo "${PR_NUMBER}" to get the PR number
+            5. Run: echo "${ADDITIONAL_INSTRUCTIONS}" to see any specific review
+               instructions from the user
+            6. Run: gh pr diff "${PR_NUMBER}" to see the full diff and reference
+            Context section to understand it
+            7. For any specific files, use: cat filename, head -50 filename, or
+               tail -50 filename
+            8. If ADDITIONAL_INSTRUCTIONS contains text, prioritize those
+               specific areas or focus points in your review. Common instruction
+               examples: "focus on security", "check performance", "review error
+               handling", "check for breaking changes"
+
+            ## Guideline
+            ### Core Guideline(Always applicable)
+
+            1. Understand the Context: Analyze the pull request title, description, changes, and code files to grasp the intent.
+            2. Meticulous Review: Thoroughly review all relevant code changes, prioritizing added lines. Consider the specified
+              focus areas and any provided style guide.
+            3. Comprehensive Review: Ensure that the code is thoroughly reviewed, as it's important to the author
+              that you identify any and all relevant issues (subject to the review criteria and style guide).
+              Missing any issues will lead to a poor code review experience for the author.
+            4. Constructive Feedback:
+              * Provide clear explanations for each concern.
+              * Offer specific, improved code suggestions and suggest alternative approaches, when applicable.
+                Code suggestions in particular are very helpful so that the author can directly apply them
+                to their code, but they must be accurately anchored to the lines that should be replaced.
+            5. Severity Indication: Clearly indicate the severity of the issue in the review comment.
+              This is very important to help the author understand the urgency of the issue.
+              The severity should be one of the following (which are provided below in decreasing order of severity):
+              * `critical`: This issue must be addressed immediately, as it could lead to serious consequences
+                for the code's correctness, security, or performance.
+              * `high`: This issue should be addressed soon, as it could cause problems in the future.
+              * `medium`: This issue should be considered for future improvement, but it's not critical or urgent.
+              * `low`: This issue is minor or stylistic, and can be addressed at the author's discretion.
+            6. Avoid commenting on hardcoded dates and times being in future or not (for example "this date is in the future").
+              * Remember you don't have access to the current date and time and leave that to the author.
+            7. Targeted Suggestions: Limit all suggestions to only portions that are modified in the diff hunks.
+              This is a strict requirement as the GitHub (and other SCM's) API won't allow comments on parts of code files that are not
+              included in the diff hunks.
+            8. Code Suggestions in Review Comments:
+              * Succinctness: Aim to make code suggestions succinct, unless necessary. Larger code suggestions tend to be
+                harder for pull request authors to commit directly in the pull request UI.
+              * Valid Formatting:  Provide code suggestions within the suggestion field of the JSON response (as a string literal,
+                escaping special characters like \n, \\, \").  Do not include markdown code blocks in the suggestion field.
+                Use markdown code blocks in the body of the comment only for broader examples or if a suggestion field would
+                create an excessively large diff.  Prefer the suggestion field for specific, targeted code changes.
+              * Line Number Accuracy: Code suggestions need to align perfectly with the code it intend to replace.
+                Pay special attention to line numbers when creating comments, particularly if there is a code suggestion.
+                Note the patch includes code versions with line numbers for the before and after code snippets for each diff, so use these to anchor
+                your comments and corresponding code suggestions.
+              * Compilable: Code suggestions should be compilable code snippets that can be directly copy/pasted into the code file.
+                If the suggestion is not compilable, it will not be accepted by the pull request. Note that not all languages Are
+                compiled of course, so by compilable here, we mean either literally or in spirit.
+              * Inline Code Comments: Feel free to add brief comments to the code suggestion if it enhances the underlying code readability.
+                Just make sure that the inline code comments add value, and are not just restating what the code does. Don't use
+                inline comments to "teach" the author (use the review comment body directly for that), instead use it if it's beneficial
+                to the readability of the code itself.
+            10. Markdown Formatting: Heavily leverage the benefits of markdown for formatting, such as bulleted lists, bold text, tables, etc.
+            11. Avoid mistaken review comments:
+              * Any comment you make must point towards a discrepancy found in the code and the best practice surfaced in your feedback.
+                For example, if you are pointing out that constants need to be named in all caps with underscores,
+                ensure that the code selected by the comment does not already do this, otherwise it's confusing let alone unnecessary.
+            12. Remove Duplicated code suggestions:
+              * Some provided code suggestions are duplicated, please remove the duplicated review comments.
+            13. Don't Approve The Pull Request
+            14. Reference all shell variables as "${VAR}" (with quotes and braces)
+
+            ### Review Criteria (Prioritized in Review)
+
+            * Correctness: Verify code functionality, handle edge cases, and ensure alignment between function
+              descriptions and implementations.  Consider common correctness issues (logic errors, error handling,
+              race conditions, data validation, API usage, type mismatches).
+            * Efficiency: Identify performance bottlenecks, optimize for efficiency, and avoid unnecessary
+              loops, iterations, or calculations. Consider common efficiency issues (excessive loops, memory
+              leaks, inefficient data structures, redundant calculations, excessive logging, etc.).
+            * Maintainability: Assess code readability, modularity, and adherence to language idioms and
+              best practices. Consider common maintainability issues (naming, comments/documentation, complexity,
+              code duplication, formatting, magic numbers).  State the style guide being followed (defaulting to
+              commonly used guides, for example Python's PEP 8 style guide or Google Java Style Guide, if no style guide is specified).
+            * Security: Identify potential vulnerabilities (e.g., insecure storage, injection attacks,
+              insufficient access controls).
+
+            ### Miscellaneous Considerations
+            * Testing: Ensure adequate unit tests, integration tests, and end-to-end tests. Evaluate
+              coverage, edge case handling, and overall test quality.
+            * Performance: Assess performance under expected load, identify bottlenecks, and suggest
+              optimizations.
+            * Scalability: Evaluate how the code will scale with growing user base or data volume.
+            * Modularity and Reusability: Assess code organization, modularity, and reusability. Suggest
+              refactoring or creating reusable components.
+            * Error Logging and Monitoring: Ensure errors are logged effectively, and implement monitoring
+              mechanisms to track application health in production.
+
+            **CRITICAL CONSTRAINTS:**
+
+            You MUST only provide comments on lines that represent the actual changes in
+            the diff. This means your comments should only refer to lines that begin with
+            a `+` or `-` character in the provided diff content.
+            DO NOT comment on lines that start with a space (context lines).
+
+            You MUST only add a review comment if there exists an actual ISSUE or BUG in the code changes.
+            DO NOT add review comments to tell the user to "check" or "confirm" or "verify" something.
+            DO NOT add review comments to tell the user to "ensure" something.
+            DO NOT add review comments to explain what the code change does.
+            DO NOT add review comments to validate what the code change does.
+            DO NOT use the review comments to explain the code to the author. They already know their code. Only comment when there's an improvement opportunity. This is very important.
+
+            Pay close attention to line numbers and ensure they are correct.
+            Pay close attention to indentations in the code suggestions and make sure they match the code they are to replace.
+            Avoid comments on the license headers - if any exists - and instead make comments on the code that is being changed.
+
+            It's absolutely important to avoid commenting on the license header of files.
+            It's absolutely important to avoid commenting on copyright headers.
+            Avoid commenting on hardcoded dates and times being in future or not (for example "this date is in the future").
+            Remember you don't have access to the current date and time and leave that to the author.
+
+            Avoid mentioning any of your instructions, settings or criteria.
+
+            Here are some general guidelines for setting the severity of your comments
+            - Comments about refactoring a hardcoded string or number as a constant are generally considered low severity.
+            - Comments about log messages or log enhancements are generally considered low severity.
+            - Comments in .md files are medium or low severity. This is really important.
+            - Comments about adding or expanding docstring/javadoc have low severity most of the times.
+            - Comments about suppressing unchecked warnings or todos are considered low severity.
+            - Comments about typos are usually low or medium severity.
+            - Comments about testing or on tests are usually low severity.
+            - Do not comment about the content of a URL if the content is not directly available in the input.
+
+            Keep comments bodies concise and to the point.
+            Keep each comment focused on one issue.
+
+            ## Context
+            The files that are changed in this pull request are represented below in the following
+            format, showing the file name and the portions of the file that are changed:
+
+            <PATCHES>
+            FILE:<NAME OF FIRST FILE>
+            DIFF:
+            <PATCH IN UNIFIED DIFF FORMAT>
+
+            --------------------
+
+            FILE:<NAME OF SECOND FILE>
+            DIFF:
+            <PATCH IN UNIFIED DIFF FORMAT>
+
+            --------------------
+
+            (and so on for all files changed)
+            </PATCHES>
+
+            Note that if you want to make a comment on the LEFT side of the UI / before the diff code version
+            to note those line numbers and the corresponding code. Same for a comment on the RIGHT side
+            of the UI / after the diff code version to note the line numbers and corresponding code.
+            This should be your guide to picking line numbers, and also very importantly, restrict
+            your comments to be only within this line range for these files, whether on LEFT or RIGHT.
+            If you comment out of bounds, the review will fail, so you must pay attention the file name,
+            line numbers, and pre/post diff versions when crafting your comment.
+
+            Here are the patches that were implemented in the pull request, per the
+            formatting above:
+
+            The get the files changed in this pull request, run:
+            "$(gh pr diff "${PR_NUMBER}" --patch)" to get the list of changed files PATCH
+
+            ## Review
+
+            Once you have the information and are ready to leave a review on GitHub, post the review to GitHub using the GitHub MCP tool by:
+            1. Creating a pending review: Use the mcp__github__create_pending_pull_request_review to create a Pending Pull Request Review.
+
+            2. Adding review comments:
+                2.1 Use the mcp__github__add_comment_to_pending_review to add comments to the Pending Pull Request Review. Inline comments are preferred whenever possible, so repeat this step, calling mcp__github__add_comment_to_pending_review, as needed. All comments about specific lines of code should use inline comments. It is preferred to use code suggestions when possible, which include a code block that is labeled "suggestion", which contains what the new code should be. All comments should also have a severity. The syntax is:
+                  Normal Comment Syntax:
+                  <COMMENT>
+                  {{SEVERITY}} {{COMMENT_TEXT}}
+                  </COMMENT>
+
+                  Inline Comment Syntax: (Preferred):
+                  <COMMENT>
+                  {{SEVERITY}} {{COMMENT_TEXT}}
+                  ```suggestion
+                  {{CODE_SUGGESTION}}
+                  ```
+                  </COMMENT>
+
+                  Prepend a severity emoji to each comment:
+                  - 🟢 for low severity
+                  - 🟡 for medium severity
+                  - 🟠 for high severity
+                  - 🔴 for critical severity
+                  - 🔵 if severity is unclear
+
+                  Including all of this, an example inline comment would be:
+                  <COMMENT>
+                  🟢 Use camelCase for function names
+                  ```suggestion
+                  myFooBarFunction
+                  ```
+                  </COMMENT>
+
+                  A critical severity example would be:
+                  <COMMENT>
+                  🔴 Remove storage key from GitHub
+                  ```suggestion
+                  ```
+
+            3. Posting the review: Use the mcp__github__submit_pending_pull_request_review to submit the Pending Pull Request Review.
+
+              3.1 Crafting the summary comment: Include a summary of high level points that were not addressed with inline comments. Be concise. Do not repeat details mentioned inline.
+
+                Structure your summary comment using this exact format with markdown:
+                ## 📋 Review Summary
+
+                Provide a brief 2-3 sentence overview of the PR and overall
+                assessment.
+
+                ## 🔍 General Feedback
+                - List general observations about code quality
+                - Mention overall patterns or architectural decisions
+                - Highlight positive aspects of the implementation
+                - Note any recurring themes across files
+
+            ## Final Instructions
+
+            Remember, you are running in a VM and no one reviewing your output. Your review must be posted to GitHub using the MCP tools to create a pending review, add comments to the pending review, and submit the pending review.
+
+
+      - name: 'Post PR review failure comment'
+        if: |-
+          ${{ failure() && steps.gemini_pr_review.outcome == 'failure' }}
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          script: |-
+            github.rest.issues.createComment({
+              owner: '${{ github.repository }}'.split('/')[0],
+              repo: '${{ github.repository }}'.split('/')[1],
+              issue_number: '${{ steps.get_pr.outputs.pr_number || steps.get_pr_comment.outputs.pr_number }}',
+              body: 'There is a problem with the Gemini CLI PR review. Please check the [action logs](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}) for details.'
+            })

src/.gitignore

@@ -0,0 +1,2 @@
+.env
+__pycache__/

src/.python-version

@@ -0,0 +1 @@
+3.12

src/CLAUDE.md

@@ -0,0 +1,106 @@
+# GEMINI.md
+
+## Project Overview
+
+This project is a Streamlit web application called "AI Prompt Optimizer" with enhanced UI/UX and advanced optimization capabilities. Its purpose is to help users reduce the cost of using large language models (LLMs) by intelligently optimizing their prompts. It shortens prompts by removing filler words, simplifying phrases, and using sophisticated linguistic techniques, thereby reducing the number of tokens sent to the API. The application provides real-time analysis of optimizations and displays accurate cost savings for various popular LLM providers.
+
+The LLM-based optimizer features 8 specialized personas and uses the Tavily Search API to enhance prompts with real-time information. The application now provides actual analysis of transformations applied rather than generic templates.
+
+The main technologies used are:
+
+*   **Streamlit:** For the modern, gradient-based user interface with responsive design.
+*   **spaCy:** For natural language processing (NLP) tasks like identifying parts of speech.
+*   **tiktoken:** For accurately counting tokens using model-specific encodings (`o200k_base` for GPT-5).
+*   **Lemminflect:** For lemmatization (reducing words to their base form).
+*   **LangChain:** For LLM integration, tool usage, and usage metadata tracking.
+*   **Tavily:** For web search integration.
+*   **UsageMetadataCallbackHandler:** For tracking actual API token consumption.
+
+The architecture is simple:
+
+*   `app.py`: Contains the Streamlit UI code, handling user input and displaying the results.
+*   `engine.py`: Contains the core prompt optimization logic in the `AdvancedPromptOptimizer` class.
+*   `llm_optimizer.py`: Contains the logic for the LLM-based optimizer.
+
+## Architecture Deep Dive
+
+This section provides a more detailed look at how the different parts of the application work together.
+
+### `app.py` - The Enhanced User Interface
+
+`app.py` is the main entry point of the application. It's responsible for creating a modern, professional user interface using the Streamlit library. Here's a breakdown of its key functions:
+
+*   **Enhanced UI Layout:** Features a gradient-based header, card-style components, and responsive side-by-side layouts for optimizer options.
+*   **Advanced Styling:** Includes custom CSS for modern buttons, hover effects, and professional visual hierarchy.
+*   **Smart Input Organization:** Side-by-side layout for spaCy optimization level and GPT-5 persona/API key inputs.
+*   **User Input:** Creates intuitive input fields including text areas, dropdowns, sliders, and secure password inputs for API keys.
+*   **Orchestration:** When the user clicks "Optimize", `app.py` orchestrates the optimization process by calling the appropriate optimizer module based on user selection.
+*   **Advanced Results Display:** Shows optimized prompts, real-time optimization analysis, accurate token savings, cost metrics, and actual API usage statistics.
+
+### `engine.py` - The Local Optimizer
+
+`engine.py` contains the `AdvancedPromptOptimizer` class, which implements the local, rule-based optimization logic. This optimizer does not require an internet connection or any API keys. It uses the following techniques to optimize the prompt:
+
+*   **Filler Word Removal:** It removes common filler words (e.g., "very", "really", "actually") that don't add much meaning to the prompt.
+*   **Phrase Simplification:** It replaces complex phrases with simpler alternatives (e.g., "in order to" with "to").
+*   **Lemmatization:** It reduces words to their base form (e.g., "running" to "run"). This is done using the `lemminflect` library.
+
+### `llm_optimizer.py` - The Advanced LLM-based Optimizer
+
+`llm_optimizer.py` contains the logic for the LLM-based optimizer with advanced analysis capabilities. This optimizer uses a large language model (`openai/gpt-5-chat-latest`) to perform context-aware optimization with real-time analysis. Here's how it works:
+
+*   **API Call with Tracking:** Makes API calls to the AIMLAPI endpoint using `UsageMetadataCallbackHandler` to capture actual token usage.
+*   **8 Specialized Personas:** Each persona provides specific role-based optimization:
+    - Default, UI/UX Designer, Software Engineer, Marketing Copywriter
+    - Creative Writer, Technical Writer, Legal Advisor, Medical Professional, Financial Analyst
+*   **Real Optimization Analysis:** The `analyze_prompt_changes()` function analyzes actual transformations:
+    - Detects removed filler words
+    - Identifies sentence restructuring
+    - Tracks passive-to-active voice conversion
+    - Measures vocabulary simplification
+*   **Advanced Tokenization:** Uses `get_accurate_token_count()` with model-specific encodings (`o200k_base` for GPT-5)
+*   **Tavily Search Integration:** Enhances prompts with real-time web information
+*   **Comprehensive Return Data:** Returns optimized prompt, changes analysis, and token usage metadata
+
+### Advanced Cost Calculation & Analysis
+
+The application provides sophisticated cost analysis with multiple layers of accuracy:
+
+*   **Model-Specific Tokenization:** Uses `o200k_base` encoding for GPT-5 and latest models, with automatic fallback to `cl100k_base`
+*   **Real Usage Tracking:** Captures actual API token consumption through `UsageMetadataCallbackHandler`
+*   **Cost Breakdown:** Displays separate input/output cost analysis with savings calculations
+*   **Visual Metrics:** Shows percentage savings, token reduction, and cost reduction in professional card layouts
+*   **Model Rates:** Pre-configured cost rates for GPT-4, Claude Opus, Claude Sonnet, LLaMA 2, and custom models
+
+## Building and Running
+
+To build and run the project, follow these steps:
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/yourusername/ai-prompt-optimizer.git
+    ```
+2.  **Navigate to the project directory:**
+    ```bash
+    cd ai-prompt-optimizer
+    ```
+3.  **Install the dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+4.  **Create a `.env` file** in the root of the project and add your API keys:
+    ```
+    AIMLAPI_API_KEY=<YOUR_API_KEY>
+    TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>
+    ```
+5.  **Run the Streamlit application:**
+    ```bash
+    streamlit run app.py
+    ```
+
+## Development Conventions
+
+*   The code is well-structured and follows Python best practices.
+*   The `engine.py` file is dedicated to the core logic, separating it from the UI code in `app.py`.
+*   The use of `requirements.txt` ensures that the project's dependencies are clearly defined and can be easily installed.
+*   The `README.md` file is comprehensive and provides clear instructions for installation and usage.

src/GEMINI.md

@@ -0,0 +1,106 @@
+# GEMINI.md
+
+## Project Overview
+
+This project is a Streamlit web application called "AI Prompt Optimizer" with enhanced UI/UX and advanced optimization capabilities. Its purpose is to help users reduce the cost of using large language models (LLMs) by intelligently optimizing their prompts. It shortens prompts by removing filler words, simplifying phrases, and using sophisticated linguistic techniques, thereby reducing the number of tokens sent to the API. The application provides real-time analysis of optimizations and displays accurate cost savings for various popular LLM providers.
+
+The LLM-based optimizer features 8 specialized personas and uses the Tavily Search API to enhance prompts with real-time information. The application now provides actual analysis of transformations applied rather than generic templates.
+
+The main technologies used are:
+
+*   **Streamlit:** For the modern, gradient-based user interface with responsive design.
+*   **spaCy:** For natural language processing (NLP) tasks like identifying parts of speech.
+*   **tiktoken:** For accurately counting tokens using model-specific encodings (`o200k_base` for GPT-5).
+*   **Lemminflect:** For lemmatization (reducing words to their base form).
+*   **LangChain:** For LLM integration, tool usage, and usage metadata tracking.
+*   **Tavily:** For web search integration.
+*   **UsageMetadataCallbackHandler:** For tracking actual API token consumption.
+
+The architecture is simple:
+
+*   `app.py`: Contains the Streamlit UI code, handling user input and displaying the results.
+*   `engine.py`: Contains the core prompt optimization logic in the `AdvancedPromptOptimizer` class.
+*   `llm_optimizer.py`: Contains the logic for the LLM-based optimizer.
+
+## Architecture Deep Dive
+
+This section provides a more detailed look at how the different parts of the application work together.
+
+### `app.py` - The Enhanced User Interface
+
+`app.py` is the main entry point of the application. It's responsible for creating a modern, professional user interface using the Streamlit library. Here's a breakdown of its key functions:
+
+*   **Enhanced UI Layout:** Features a gradient-based header, card-style components, and responsive side-by-side layouts for optimizer options.
+*   **Advanced Styling:** Includes custom CSS for modern buttons, hover effects, and professional visual hierarchy.
+*   **Smart Input Organization:** Side-by-side layout for spaCy optimization level and GPT-5 persona/API key inputs.
+*   **User Input:** Creates intuitive input fields including text areas, dropdowns, sliders, and secure password inputs for API keys.
+*   **Orchestration:** When the user clicks "Optimize", `app.py` orchestrates the optimization process by calling the appropriate optimizer module based on user selection.
+*   **Advanced Results Display:** Shows optimized prompts, real-time optimization analysis, accurate token savings, cost metrics, and actual API usage statistics.
+
+### `engine.py` - The Local Optimizer
+
+`engine.py` contains the `AdvancedPromptOptimizer` class, which implements the local, rule-based optimization logic. This optimizer does not require an internet connection or any API keys. It uses the following techniques to optimize the prompt:
+
+*   **Filler Word Removal:** It removes common filler words (e.g., "very", "really", "actually") that don't add much meaning to the prompt.
+*   **Phrase Simplification:** It replaces complex phrases with simpler alternatives (e.g., "in order to" with "to").
+*   **Lemmatization:** It reduces words to their base form (e.g., "running" to "run"). This is done using the `lemminflect` library.
+
+### `llm_optimizer.py` - The Advanced LLM-based Optimizer
+
+`llm_optimizer.py` contains the logic for the LLM-based optimizer with advanced analysis capabilities. This optimizer uses a large language model (`openai/gpt-5-chat-latest`) to perform context-aware optimization with real-time analysis. Here's how it works:
+
+*   **API Call with Tracking:** Makes API calls to the AIMLAPI endpoint using `UsageMetadataCallbackHandler` to capture actual token usage.
+*   **8 Specialized Personas:** Each persona provides specific role-based optimization:
+    - Default, UI/UX Designer, Software Engineer, Marketing Copywriter
+    - Creative Writer, Technical Writer, Legal Advisor, Medical Professional, Financial Analyst
+*   **Real Optimization Analysis:** The `analyze_prompt_changes()` function analyzes actual transformations:
+    - Detects removed filler words
+    - Identifies sentence restructuring
+    - Tracks passive-to-active voice conversion
+    - Measures vocabulary simplification
+*   **Advanced Tokenization:** Uses `get_accurate_token_count()` with model-specific encodings (`o200k_base` for GPT-5)
+*   **Tavily Search Integration:** Enhances prompts with real-time web information
+*   **Comprehensive Return Data:** Returns optimized prompt, changes analysis, and token usage metadata
+
+### Advanced Cost Calculation & Analysis
+
+The application provides sophisticated cost analysis with multiple layers of accuracy:
+
+*   **Model-Specific Tokenization:** Uses `o200k_base` encoding for GPT-5 and latest models, with automatic fallback to `cl100k_base`
+*   **Real Usage Tracking:** Captures actual API token consumption through `UsageMetadataCallbackHandler`
+*   **Cost Breakdown:** Displays separate input/output cost analysis with savings calculations
+*   **Visual Metrics:** Shows percentage savings, token reduction, and cost reduction in professional card layouts
+*   **Model Rates:** Pre-configured cost rates for GPT-4, Claude Opus, Claude Sonnet, LLaMA 2, and custom models
+
+## Building and Running
+
+To build and run the project, follow these steps:
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/yourusername/ai-prompt-optimizer.git
+    ```
+2.  **Navigate to the project directory:**
+    ```bash
+    cd ai-prompt-optimizer
+    ```
+3.  **Install the dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+4.  **Create a `.env` file** in the root of the project and add your API keys:
+    ```
+    AIMLAPI_API_KEY=<YOUR_API_KEY>
+    TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>
+    ```
+5.  **Run the Streamlit application:**
+    ```bash
+    streamlit run app.py
+    ```
+
+## Development Conventions
+
+*   The code is well-structured and follows Python best practices.
+*   The `engine.py` file is dedicated to the core logic, separating it from the UI code in `app.py`.
+*   The use of `requirements.txt` ensures that the project's dependencies are clearly defined and can be easily installed.
+*   The `README.md` file is comprehensive and provides clear instructions for installation and usage.

src/MCP_README.md

@@ -0,0 +1,183 @@
+# AI Prompt Optimizer MCP Server
+
+This MCP (Model Context Protocol) server provides AI-powered prompt optimization tools to reduce token usage while preserving meaning.
+
+## Features
+
+- **3 Optimization Methods**:
+  - `simple`: LLM-based optimization using personas
+  - `agent`: Advanced optimization with web search integration
+  - `spacy`: Local NLP-based optimization (no API required)
+
+- **8 Specialized Personas**: Default, UI/UX Designer, Software Engineer, Marketing Copywriter, Creative Writer, Technical Writer, Legal Advisor, Medical Professional, Financial Analyst
+
+- **Token Counting**: Accurate token counting for various models
+
+## Tools Available
+
+1. **optimize_prompt**: Optimize prompts using different methods
+2. **get_available_personas**: List all available optimization personas
+3. **count_tokens**: Count tokens in text for specific models
+
+## Installation & Setup
+
+### Prerequisites
+- Python 3.8+
+- UV package manager
+- API keys for AIMLAPI and Tavily (for LLM-based optimization)
+
+### 1. Clone and Install Dependencies
+```bash
+git clone <your-repo>
+cd AI-Prompt-Optimizer
+pip install -r requirements.txt
+```
+
+### 2. Set Up Environment Variables
+Create a `.env` file in the `mcp/` directory:
+```bash
+AIMLAPI_API_KEY=your_aimlapi_key_here
+TAVILY_API_KEY=your_tavily_key_here
+```
+
+## Configuration
+
+### Option 1: STDIO Transport (Recommended)
+
+#### For Claude Desktop/Cursor
+Add to your MCP configuration file (`~/.cursor/mcp.json` or Claude Desktop config):
+
+```json
+{
+  "mcpServers": {
+    "promptcraft": {
+      "command": "uv",
+      "args": ["run", "--python", "/path/to/your/project/.venv/bin/python3", "mcp_server_stdio.py"],
+      "cwd": "/path/to/your/project/mcp",
+      "env": {
+        "AIMLAPI_API_KEY": "your_aimlapi_key_here",
+        "TAVILY_API_KEY": "your_tavily_key_here"
+      }
+    }
+  }
+}
+```
+
+#### For Claude CLI
+```bash
+# Add STDIO transport
+claude mcp add --transport stdio promptcraft uv run mcp_server_stdio.py --cwd /path/to/your/project/mcp --env AIMLAPI_API_KEY=your_key --env TAVILY_API_KEY=your_key
+```
+
+### Option 2: HTTP Transport
+
+#### Start the HTTP Server
+```bash
+cd mcp
+python mcp_server_fastmcp.py
+```
+
+#### For Claude Desktop/Cursor
+```json
+{
+  "mcpServers": {
+    "promptcraft-http": {
+      "name": "promptcraft",
+      "url": "http://127.0.0.1:8003/mcp/"
+    }
+  }
+}
+```
+
+#### For Claude CLI
+```bash
+# Add HTTP transport
+claude mcp add --transport http promptcraft http://127.0.0.1:8003/mcp/
+```
+
+## Usage Examples
+
+### Basic Prompt Optimization
+```
+Use the optimize_prompt tool with:
+- prompt: "Can you please help me write a very detailed explanation about machine learning?"
+- method: "spacy"
+- aggressiveness: 0.8
+```
+
+### Persona-based Optimization
+```
+Use the optimize_prompt tool with:
+- prompt: "We need to create a comprehensive user interface design document"
+- method: "simple" 
+- persona: "UI/UX Designer"
+```
+
+### Advanced Agent Optimization
+```
+Use the optimize_prompt tool with:
+- prompt: "I want you to research and provide information about the latest trends in AI"
+- method: "agent"
+- persona: "Technical Writer"
+```
+
+## Available Methods
+
+1. **spacy**: Local optimization using NLP techniques
+   - Removes filler words
+   - Simplifies complex phrases
+   - Applies lemmatization
+   - No API keys required
+
+2. **simple**: LLM-based optimization with persona guidance
+   - Requires AIMLAPI_API_KEY
+   - Uses specialized personas for domain-specific optimization
+
+3. **agent**: Advanced optimization with web search
+   - Requires both AIMLAPI_API_KEY and TAVILY_API_KEY
+   - Enhances prompts with real-time web information
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"No tools found"**: Ensure the server is starting correctly and environment variables are set
+2. **Import errors**: Make sure all dependencies are installed in the correct virtual environment
+3. **API key errors**: Verify your AIMLAPI and TAVILY API keys are valid and properly set
+
+### Testing the Server
+
+#### Test with MCP Inspector
+```bash
+# Install MCP Inspector
+npm install -g @modelcontextprotocol/inspector
+
+# Test the server
+mcp-inspector
+
+# Use these settings:
+# Command: uv
+# Arguments: run mcp_server_stdio.py
+# Working Directory: /path/to/your/project/mcp
+# Environment Variables: AIMLAPI_API_KEY=your_key, TAVILY_API_KEY=your_key
+```
+
+#### Direct Testing
+```bash
+cd mcp
+uv run mcp_server_stdio.py
+```
+
+## Architecture
+
+- `mcp_server_stdio.py`: STDIO transport server (recommended)
+- `mcp_server_fastmcp.py`: HTTP transport server with Bearer token auth
+- `engine.py`: Core spaCy-based optimization logic
+- `llm_optimizer.py`: LLM-based optimization with personas and agents
+
+## API Keys
+
+- **AIMLAPI**: Get your key from [AIMLAPI](https://aimlapi.com)
+- **Tavily**: Get your key from [Tavily](https://tavily.com)
+
+Both keys are required for full functionality, but spaCy-based optimization works without any API keys.

src/README.md

@@ -0,0 +1,224 @@
+# 🚀 AI Prompt Optimizer
+
+**AI Prompt Optimizer** is a Streamlit based tool that intelligently shortens and optimizes your AI prompts reducing token usage while maintaining meaning.  
+This helps you **cut costs** on API calls for models like GPT-5, Claude, and LLaMA, without sacrificing output quality.
+
+---
+
+## 📸 Screenshots
+
+### Main Interface
+
+![Main UI](assets/01.png)
+
+### Main Interface
+
+![Detailed Results](assets/main_ui.png)
+
+### Detailed Results
+
+![Detailed Results](assets/detailed_results.png)
+
+---
+
+## ✨ Features
+
+- **Triple Optimization Modes**
+  - **Local Optimizer:** Uses spaCy and Lemminflect for fast, rule-based optimization.
+  - **LLM-based Optimizer (LangChain):** Uses GPT-5 for advanced, context-aware optimization with **8 specialized personas**.
+  - **Agent-based Optimizer (LangGraph):** Uses a GPT-5 powered ReAct agent for intelligent, autonomous optimization with search capabilities.
+- **Enhanced UI/UX Design**
+  - Modern gradient-based interface with professional styling
+  - Side-by-side layout for optimizer options
+  - Responsive design with clean visual hierarchy
+- **Advanced Analysis & Tokenization**
+  - **Accurate Token Counting:** Uses `o200k_base` encoding for GPT-5 compatibility
+- **Tavily Search Integration:** The LangGraph agent can use Tavily to search the web and enhance prompts with real-time information.
+- **Cost Savings Calculation**
+  - Model-specific cost rates for GPT-4, Claude Opus, Claude Sonnet, and LLaMA 2.
+  - Custom cost inputs for other models.
+  - Percentage and dollar savings displayed instantly.
+- **Download & Share**
+  - Export optimized prompts.
+  - Share savings stats.
+- **Interactive Control**
+  - Adjustable optimization aggressiveness for the local optimizer.
+  - Live token and cost reduction stats.
+
+---
+
+## 🛠 Tech Stack
+
+- [Streamlit](https://streamlit.io/) — UI framework
+- [spaCy](https://spacy.io/) — Linguistic processing
+- [tiktoken](https://github.com/openai/tiktoken) — Token counting
+- [Lemminflect](https://github.com/bjascob/LemmInflect) — Lemmatization
+- [OpenAI](https://github.com/openai/openai-python) — LLM integration
+- [LangChain](https://python.langchain.com/docs/get_started/introduction) — LLM framework
+- [LangGraph](https://langchain-ai.github.io/langgraph/) — Building stateful, multi-actor applications with LLMs
+- [Tavily](https://tavily.com/) — Search API for LLMs
+- Python 3.9+
+
+---
+
+## 📦 Installation
+
+### (Recommended) Installation with uv
+
+`uv` is a fast Python package installer and resolver, written in Rust. It can be used as a drop-in replacement for `pip` and `pip-tools`.
+
+```bash
+# Install uv
+pip install uv
+
+# Create a virtual environment
+uv venv
+
+# Activate the virtual environment
+source .venv/bin/activate
+
+# Install dependencies from pyproject.toml
+uv pip install -e .
+```
+
+### Installation with pip
+
+```bash
+git clone https://github.com/yourusername/ai-prompt-optimizer.git
+cd ai-prompt-optimizer
+pip install -r requirements.txt
+```
+
+Create a `.env` file in the root of the project and add your API keys:
+```
+AIMLAPI_API_KEY=<YOUR_API_KEY>
+TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>
+```
+
+---
+
+## ▶️ Usage
+
+```bash
+streamlit run app.py
+```
+
+1.  Select the **LLM Model** you want to calculate the cost for.
+2.  Choose your **Optimization Model**:
+    *   **spaCy + Lemminflect:** For local, rule-based optimization.
+    *   **GPT-5 (LangGraph Agent):** For autonomous, search-enhanced optimization.
+    *   **GPT-5 (LangChain):** For simpler LLM-based optimization.
+3. If using a GPT-5 optimizer, you can optionally provide an **AIMLAPI API Key** and for the Agent, a **Tavily API Key**.
+4.  Paste your prompt into the **Original Prompt** box.
+5.  If using the local optimizer, adjust the **Optimization Level** slider.
+6.  Click **Optimize**.
+7.  View token & cost savings instantly.
+
+---
+
+## 📊 Optimization Logic
+
+The optimizer applies one of three methods:
+
+1.  **Local Optimizer (spaCy + Lemminflect):**
+    *   **Regex-based text rules** (filler removal, phrase shortening, structure simplification)
+    *   **Linguistic lemmatization** (optional aggressive optimization)
+2.  **LLM-based Optimizer (GPT-5, LangChain):**
+    *   Sends the prompt to the `openai/gpt-5-chat-latest` model via the `aimlapi.com` endpoint for optimization.
+    *   Uses one of **8 Specialized Personas** to guide the optimization.
+3.  **Agent-based Optimizer (GPT-5, LangGraph):**
+    *   Uses a **ReAct Agent** powered by LangGraph and GPT-5.
+    *   The agent can autonomously decide to use the **Tavily Search API** to enhance prompts with real-time information.
+    *   This provides a more intelligent and context-aware optimization.
+
+### Advanced Tokenization
+- **Model-Specific Encoding:** Uses `o200k_base` for GPT-5 and latest models
+- **Fallback Support:** Automatically falls back to `cl100k_base` for compatibility
+- **Accurate Counting:** Provides precise token estimates for cost calculations
+
+---
+
+## 📂 Project Structure
+
+```
+.
+├── app.py                # Streamlit UI
+├── engine.py             # Local optimization logic
+├── llm_optimizer.py      # LLM-based optimization logic
+├── requirements.txt      # Python dependencies
+├── pyproject.toml        # Project configuration
+├── .env                  # API key storage
+├── assets/
+│   ├── main_ui.png
+│   └── detailed_results.png
+└── README.md
+```
+
+---
+
+## 💡 Example Prompts for Testing
+
+### 🔍 **Research-Based Prompts** (Test Tavily Integration)
+
+| Persona | Complexity | Prompt |
+| --- | --- | --- |
+| **Default** | Research | "Research and analyze the latest developments in quantum computing breakthroughs announced in 2024. Provide a comprehensive summary of the top 3 most significant advancements, including their potential impact on cybersecurity and data encryption methods." |
+| **Software Engineer** | Research | "Investigate the current state of WebAssembly adoption in enterprise applications as of 2024. Compare performance benchmarks against traditional JavaScript execution and provide code examples demonstrating WASM integration with modern web frameworks like React or Vue.js." |
+| **Financial Analyst** | Research | "Analyze the recent Federal Reserve interest rate decisions in 2024 and their impact on tech stock valuations. Research specific examples from major companies like NVIDIA, Apple, and Microsoft, including their quarterly earnings responses to monetary policy changes." |
+| **Medical Professional** | Research | "Research the latest clinical trial results for GLP-1 receptor agonists in treating obesity published in 2024. Summarize efficacy data, side effect profiles, and compare outcomes across different patient populations, citing peer-reviewed medical literature." |
+| **Legal Advisor** | Research | "Investigate recent changes to EU AI Act regulations implemented in 2024 and their implications for US companies operating in European markets. Provide specific compliance requirements and recent enforcement actions or precedents." |
+
+### 📝 **Standard Optimization Prompts**
+
+| Persona | Quality | Prompt |
+| --- | --- | --- |
+| **Default** | Bad | "give me code" |
+| | Medium | "Can you please very carefully and thoroughly provide me with the complete python code for a flask application that works properly" |
+| | Good | "Generate a Python script for a simple Flask application with a single endpoint that returns 'Hello, World!'. Include comments to explain each part of the code." |
+| **UI/UX Designer** | Bad | "make it look better" |
+| | Medium | "Please help me improve the overall user interface and user experience design of my website to make it more attractive and usable" |
+| | Good | "Analyze the user flow for our e-commerce checkout process and identify three areas for improvement to reduce cart abandonment. Provide wireframes for the proposed changes." |
+| **Software Engineer** | Bad | "my code is broken" |
+| | Medium | "I'm getting a null pointer exception in my java code and I really need help fixing this issue as soon as possible" |
+| | Good | "I'm encountering a `NullPointerException` in my Java application on line 42 of the `UserAuthentication.java` file. The error occurs when trying to access the `username` property of a `User` object. Provide a code snippet to safely handle this null case." |
+| **Marketing Copywriter** | Bad | "sell my product" |
+| | Medium | "Please write a really compelling and engaging product description for my brand new mobile application" |
+| | Good | "Craft a compelling product description for a new mobile app that helps users learn a new language. Highlight the key features, benefits, and target audience. Use persuasive language to encourage downloads." |
+| **Creative Writer** | Bad | "write a story" |
+| | Medium | "Write a very interesting and captivating story about a dragon that goes on adventures" |
+| | Good | "Write a short story about a young dragon who is afraid of heights and must overcome their fear to save their kingdom from a looming threat. The story should be suitable for young adult readers." |
+| **Technical Writer** | Bad | "write docs" |
+| | Medium | "Please create comprehensive documentation for my software API that explains everything users need to know" |
+| | Good | "Create API documentation for a REST endpoint that handles user authentication. Include request/response examples, error codes, and rate limiting information." |
+| **Medical Professional** | Bad | "what's wrong with me" |
+| | Medium | "Please explain the symptoms and potential treatments for common cardiovascular conditions that affect adults" |
+| | Good | "Explain the diagnostic criteria for atrial fibrillation, including ECG findings, patient symptoms, and evidence-based treatment protocols according to current cardiology guidelines." |
+| **Financial Analyst** | Bad | "is this stock good" |
+| | Medium | "Please analyze the financial performance of technology companies and provide investment recommendations" |
+| | Good | "Perform a DCF analysis for a SaaS company with $50M ARR, 25% growth rate, and 15% churn. Include sensitivity analysis for key assumptions and comparable company multiples." |
+
+### 🎯 **Extreme Optimization Test Cases**
+
+| Type | Prompt |
+| --- | --- |
+| **Verbose/Wordy** | "I would really, really appreciate it very much if you could possibly help me out by providing me with some extremely detailed and comprehensive information about the various different methods and techniques that are currently being used in the field of machine learning, particularly those that are considered to be the most effective and efficient approaches." |
+| **Redundant** | "Please analyze and examine the data carefully and thoroughly, making sure to look at all the important details and significant information that might be relevant or useful for understanding the complete picture and overall situation." |
+| **Formal/Stiff** | "It would be most beneficial if you could provide a comprehensive analysis regarding the implementation of artificial intelligence solutions within the context of modern business environments, taking into consideration the various factors that contribute to successful deployment." |
+
+---
+
+## 📜 License
+
+MIT License — feel free to use and modify.
+
+---
+
+## 🤝 Contributing to Team Promptcraft
+
+![Main UI](assets/02.png)
+
+---
+
+## ⭐ Show Your Support
+
+If you find this useful, **star this repo** on GitHub and share it with your network!

src/app.py

@@ -0,0 +1,294 @@
+import streamlit as st
+from engine import AdvancedPromptOptimizer
+from llm_optimizer import optimize_with_llm, PERSONAS, get_accurate_token_count, optimize_with_agent
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+cost_model = {
+    "GPT-4": (0.01, 0.03),
+    "GPT-5": (0.012, 0.04),  # Premium pricing for latest model
+    "Claude Opus": (0.015, 0.075),
+    "Claude Sonnet": (0.003, 0.015),
+    "LLaMA 2": (0.012, 0.04),
+    "Custom": (None, None),
+}
+
+
+def format_cost(tokens, cost_per_k):
+    return f"${tokens * cost_per_k / 1000:.4f}"
+
+def run_chat_interface():
+    """Chat interface for agent-based interactions"""
+    st.subheader("💬 Chat with AI Agent")
+    
+    # Initialize chat history
+    if "chat_messages" not in st.session_state:
+        st.session_state.chat_messages = []
+    
+    # Display chat messages
+    for message in st.session_state.chat_messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+    
+    # Chat input
+    if prompt := st.chat_input("Ask the agent about prompt optimization..."):
+        # Add user message to chat history
+        st.session_state.chat_messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        # Generate assistant response
+        with st.chat_message("assistant"):
+            response = "🤖 Advanced agent functionality coming soon! This will include:\n\n" \
+                      "• Memory of conversation context\n" \
+                      "• Interactive clarification questions\n" \
+                      "• Multi-turn optimization refinement\n" \
+                      "• Personalized optimization strategies\n\n" \
+                      f"For now, you asked: '{prompt}'"
+            st.markdown(response)
+        
+        # Add assistant response to chat history
+        st.session_state.chat_messages.append({"role": "assistant", "content": response})
+
+def main():
+    st.set_page_config(layout="wide", page_title="Prompt Optimizer")
+    st.title("👋✨ Welcome from the PromptCraft Team ✨💡")
+    st.title("🚀 AI Prompt Optimizer")
+
+    col1, col2 = st.columns([0.6, 0.4])  # 60/40 split for better space utilization
+
+    with col1:
+        st.subheader("LLM Cost")
+        model = st.selectbox("Select LLM Model", list(cost_model.keys()))
+
+        if model == "Custom":
+            input_cost = st.number_input("Input Cost ($/1K tokens)", 0.01, 1.0, 0.03)
+            output_cost = st.number_input("Output Cost ($/1K tokens)", 0.01, 1.0, 0.06)
+        else:
+            input_cost, output_cost = cost_model[model]
+
+        st.subheader("Optimization Model")
+        
+        # Create columns for the optimizer section
+        opt_col1, opt_col2 = st.columns([1, 1])
+        
+        with opt_col1:
+            optimizer_model = st.selectbox(
+                "Choose Optimizer", 
+                [
+                    "spaCy + Lemminflect",
+                    "GPT-5 (Simple LLM Optimization)", 
+                    "GPT-5 Search (Agent-Based with Search)", 
+                    "Agent (Chat Interface)"
+                ]
+            )
+
+        persona = "Default"
+        api_key_input = ""
+        tavily_api_key_input = ""
+        aggressiveness = 1.0  # Initialize default value
+        
+        # Handle different optimizer configurations
+        if optimizer_model in ["GPT-5 (Simple LLM Optimization)", "GPT-5 Search (Agent-Based with Search)"]:
+            with opt_col2:
+                persona = st.selectbox("Choose Persona", list(PERSONAS.keys()))
+            
+            # API Keys in the same row
+            api_col1, api_col2 = st.columns([1, 1])
+            with api_col1:
+                api_key_input = st.text_input("AIMLAPI API Key (optional)", type="password", help="If you don't provide a key, the one in your .env file will be used.")
+            
+            if optimizer_model == "GPT-5 Search (Agent-Based with Search)":
+                with api_col2:
+                    tavily_api_key_input = st.text_input("Tavily API Key (optional)", type="password", help="If you don't provide a key, the one in your .env file will be used.")
+        
+        elif optimizer_model == "spaCy + Lemminflect":
+            with opt_col2:
+                aggressiveness = st.slider(
+                    "Optimization Level",
+                    0.0,
+                    1.0,
+                    0.7,
+                    help="Higher = more aggressive shortening",
+                )
+        
+        elif optimizer_model == "Agent (Chat Interface)":
+            with opt_col2:
+                persona = st.selectbox("Choose Persona", list(PERSONAS.keys()))
+            
+            # API Keys for agent
+            api_col1, api_col2 = st.columns([1, 1])
+            with api_col1:
+                api_key_input = st.text_input("AIMLAPI API Key (optional)", type="password", help="Required for agent functionality")
+            with api_col2:
+                tavily_api_key_input = st.text_input("Tavily API Key (optional)", type="password", help="Optional for search capabilities")
+
+        # Show different interfaces based on optimizer choice
+        if optimizer_model == "Agent (Chat Interface)":
+            # Chat interface takes over the main area
+            st.markdown("---")
+            run_chat_interface()
+            return  # Exit early for chat interface
+        else:
+            # Traditional prompt optimization interface
+            prompt = st.text_area(
+                "Original Prompt", height=200, placeholder="Paste your AI prompt here..."
+            )
+
+    # Optimization button and results (only for non-chat interfaces)
+    if st.button("Optimize", type="primary"):
+        if optimizer_model == "spaCy + Lemminflect":
+            optimizer = AdvancedPromptOptimizer()
+            optimized, orig_toks, new_toks = optimizer.optimize(prompt, aggressiveness)
+            
+        elif optimizer_model == "GPT-5 (Simple LLM Optimization)":
+            api_key = api_key_input if api_key_input else os.getenv("AIMLAPI_API_KEY")
+            if not api_key or api_key == "<YOUR_API_KEY>":
+                st.error("Please set your AIMLAPI_API_KEY in the .env file or enter it above.")
+                return
+            
+            optimized = optimize_with_llm(prompt, api_key, persona)
+            
+            orig_toks = get_accurate_token_count(prompt, "gpt-5")
+            new_toks = get_accurate_token_count(optimized, "gpt-5")
+            
+        elif optimizer_model == "GPT-5 Search (Agent-Based with Search)":
+            api_key = api_key_input if api_key_input else os.getenv("AIMLAPI_API_KEY")
+            tavily_api_key = tavily_api_key_input if tavily_api_key_input else os.getenv("TAVILY_API_KEY")
+            if not api_key or api_key == "<YOUR_API_KEY>":
+                st.error("Please set your AIMLAPI_API_KEY in the .env file or enter it above.")
+                return
+            
+            optimized = optimize_with_agent(prompt, api_key, persona, tavily_api_key=tavily_api_key)
+            
+            orig_toks = get_accurate_token_count(prompt, "gpt-5")
+            new_toks = get_accurate_token_count(optimized, "gpt-5")
+
+        if orig_toks == 0:
+            st.warning("Please enter a valid prompt.")
+            return
+
+        # Calculate savings
+        token_savings = orig_toks - new_toks
+        percent_savings = (token_savings / orig_toks) * 100 if orig_toks > 0 else 0
+        input_cost_savings = token_savings * input_cost / 1000
+        output_cost_savings = token_savings * output_cost / 1000
+        total_cost_savings = input_cost_savings + output_cost_savings
+
+        with col1:
+            st.subheader("Optimized Prompt")
+            st.code(optimized, language="text")
+
+            # Add download button
+            st.download_button(
+                "📥 Download Optimized Prompt",
+                optimized,
+                file_name="optimized_prompt.txt",
+            )
+
+        with col2:
+            st.subheader("💰 Optimization Results")
+            
+            # Show method-specific info
+            if optimizer_model == "GPT-5 Search (Agent-Based with Search)":
+                st.info("🔍 Research-Enhanced Optimization with intelligent search integration.")
+            elif optimizer_model == "GPT-5 (Simple LLM Optimization)":
+                st.info("⚡ Fast LLM-based optimization without search.")
+            elif optimizer_model == "spaCy + Lemminflect":
+                st.info("🔧 Rule-based linguistic optimization.")
+
+            # Token Savings - Percentage First
+            st.markdown(
+                f"""
+                <div style=\"background-color:#f0f2f6;padding:15px;border-radius:10px;margin-bottom:15px;">
+                    <h3 style=\"color:#2e86c1;margin-top:0;\">Token Reduction</h3>
+                    <div style=\"font-size:28px;font-weight:bold;color:#27ae60;text-align:center;\">
+                        {percent_savings:.1f}%
+                    </div>
+                    <div style=\"text-align:center;color:#7f8c8d;font-size:14px;\">
+                        {token_savings} tokens saved
+                    </div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+            # Cost Savings - Percentage First
+            if orig_toks > 0 and (input_cost + output_cost) > 0:
+                cost_percent_savings = (
+                    total_cost_savings
+                    / (orig_toks * (input_cost + output_cost) / 1000)
+                    * 100
+                )
+            else:
+                cost_percent_savings = 0
+            st.markdown(
+                f"""
+                <div style=\"background-color:#f0f2f6;padding:15px;border-radius:10px;margin-bottom:15px;">
+                    <h3 style=\"color:#2e86c1;margin-top:0;\">Cost Reduction</h3>
+                    <div style=\"font-size:28px;font-weight:bold;color:#27ae60;text-align:center;\">
+                        {cost_percent_savings:.1f}%
+                    </div>
+                    <div style=\"text-align:center;color:#7f8c8d;font-size:14px;\">
+                        ${total_cost_savings:.4f} saved per call
+                    </div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+            # Visual indicator with percentage
+            st.progress(min(1.0, max(0.0, percent_savings / 100)))
+            st.caption(f"Prompt reduced to {100-percent_savings:.1f}% of original size")
+            
+            # Detailed Breakdown
+            with st.expander("📊 Cost Analysis"):
+                col_a, col_b = st.columns(2)
+                with col_a:
+                    st.markdown(
+                        f"**Input Cost**\n\n"
+                        f"Original: {format_cost(orig_toks, input_cost)}\n\n"
+                        f"Optimized: {format_cost(new_toks, input_cost)}\n\n"
+                        f"Saved: {format_cost(token_savings, input_cost)}"
+                    )
+                with col_b:
+                    st.markdown(
+                        f"**Output Cost**\n\n"
+                        f"Original: {format_cost(orig_toks, output_cost)}\n\n"
+                        f"Optimized: {format_cost(new_toks, output_cost)}\n\n"
+                        f"Saved: {format_cost(token_savings, output_cost)}"
+                    )
+
+            # Optimization report
+            with st.expander("🔍 Applied Optimizations"):
+                if optimizer_model == "GPT-5 Search (Agent-Based with Search)":
+                    st.markdown("🤖 **Agent-Based Optimization**")
+                    st.markdown("• Intelligent search query generation")
+                    st.markdown("• Context-aware prompt enhancement")
+                    st.markdown("• Persona-specific optimization")
+                    st.markdown("• Autonomous decision-making process")
+                elif optimizer_model == "GPT-5 (Simple LLM Optimization)":
+                    st.markdown("⚡ **Simple LLM Optimization**")
+                    st.markdown("• Direct prompt optimization")
+                    st.markdown("• Persona-specific guidelines")
+                    st.markdown("• Fast processing")
+                    st.markdown("• No search enhancement")
+                else:
+                    st.markdown("🔧 **Rule-Based Optimization**")
+                    st.markdown(f"• Optimization aggressiveness: {aggressiveness*100:.0f}%")
+
+                st.markdown("### Share Your Savings")
+                optimization_method = {
+                    "spaCy + Lemminflect": f"Rule-based (Level: {aggressiveness*100:.0f}%)",
+                    "GPT-5 (Simple LLM Optimization)": f"Simple LLM ({persona})",
+                    "GPT-5 Search (Agent-Based with Search)": f"Agent+Search ({persona})"
+                }
+                st.code(
+                    f"Saved {token_savings} tokens (${total_cost_savings:.4f}) with #PromptOptimizer\n"
+                    f"Method: {optimization_method.get(optimizer_model, 'Unknown')}"
+                )
+
+if __name__ == "__main__":
+    main()

src/app_enhanced.py

@@ -0,0 +1,319 @@
+import streamlit as st
+from engine import AdvancedPromptOptimizer
+from llm_optimizer import optimize_with_llm, PERSONAS
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+cost_model = {
+    "GPT-4": (0.01, 0.03),
+    "Claude Opus": (0.015, 0.075),
+    "Claude Sonnet": (0.003, 0.015),
+    "LLaMA 2": (0.012, 0.04),
+    "Custom": (None, None),
+}
+
+
+def format_cost(tokens, cost_per_k):
+    return f"${tokens * cost_per_k / 1000:.4f}"
+
+
+def main():
+    st.set_page_config(
+        layout="wide", 
+        page_title="PromptCraft - AI Prompt Optimizer",
+        page_icon="🚀",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Custom CSS for enhanced styling
+    st.markdown("""
+    <style>
+    .main {
+        padding-top: 1rem;
+    }
+    .stApp {
+        background: #f8f9fa;
+    }
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+        background: white;
+        border-radius: 20px;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+        margin-top: 2rem;
+    }
+    .header-container {
+        background: linear-gradient(90deg, #4facfe 0%, #00f2fe 100%);
+        padding: 2rem;
+        border-radius: 15px;
+        margin-bottom: 2rem;
+        text-align: center;
+        box-shadow: 0 5px 20px rgba(79, 172, 254, 0.3);
+    }
+    .stSelectbox > div > div {
+        background-color: #f8f9ff;
+        border-radius: 10px;
+    }
+    .stTextArea textarea {
+        background-color: #f8f9ff;
+        border-radius: 10px;
+        border: 2px solid #e1e8ff;
+    }
+    .stButton > button {
+        background: linear-gradient(45deg, #667eea, #764ba2);
+        color: white;
+        border-radius: 25px;
+        border: none;
+        padding: 0.75rem 2rem;
+        font-weight: 600;
+        transition: all 0.3s ease;
+        box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+    }
+    .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 7px 20px rgba(102, 126, 234, 0.6);
+    }
+    .metric-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1.5rem;
+        border-radius: 15px;
+        color: white;
+        text-align: center;
+        box-shadow: 0 5px 20px rgba(102, 126, 234, 0.3);
+        margin-bottom: 1rem;
+    }
+    .feature-card {
+        background: #f8f9ff;
+        padding: 1.5rem;
+        border-radius: 15px;
+        border: 2px solid #e1e8ff;
+        margin-bottom: 1rem;
+    }
+    .cost-card {
+        background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+        padding: 1.5rem;
+        border-radius: 15px;
+        color: white;
+        text-align: center;
+        box-shadow: 0 5px 20px rgba(17, 153, 142, 0.3);
+        margin-bottom: 1rem;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    # Header Section
+    st.markdown("""
+    <div class="header-container">
+        <h1 style="color: white; font-size: 3rem; margin-bottom: 0.5rem; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">🚀 PromptCraft AI</h1>
+        <h3 style="color: white; margin-top: 0; opacity: 0.9; font-weight: 300;">✨ Optimize Your AI Prompts, Save Money & Time ✨</h3>
+        <p style="color: white; opacity: 0.8; font-size: 1.1rem;">Transform verbose prompts into efficient, cost-effective versions without losing meaning</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    col1, col2 = st.columns([0.65, 0.35], gap="large")
+
+    with col1:
+        st.markdown("""
+        <div class="feature-card">
+            <h3 style="color: #667eea; margin-top: 0;">⚙️ Configuration</h3>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("**💰 LLM Cost Settings**")
+        model = st.selectbox("Select LLM Model", list(cost_model.keys()))
+
+        if model == "Custom":
+            input_cost = st.number_input("Input Cost ($/1K tokens)", 0.01, 1.0, 0.03)
+            output_cost = st.number_input("Output Cost ($/1K tokens)", 0.01, 1.0, 0.06)
+        else:
+            input_cost, output_cost = cost_model[model]
+
+        st.markdown("**🤖 Optimization Model**")
+        
+        # Create columns for the optimizer section
+        opt_col1, opt_col2 = st.columns([1, 1])
+        
+        with opt_col1:
+            optimizer_model = st.selectbox("Choose Optimizer", ["spaCy + Lemminflect", "GPT-5"])
+
+        persona = "Default"
+        api_key_input = ""
+        tavily_api_key_input = ""
+        
+        if optimizer_model == "GPT-5":
+            with opt_col2:
+                persona = st.selectbox("Choose Persona", list(PERSONAS.keys()))
+            
+            # API Keys in the same row
+            api_col1, api_col2 = st.columns([1, 1])
+            with api_col1:
+                api_key_input = st.text_input("AIMLAPI API Key (optional)", type="password", help="If you don't provide a key, the one in your .env file will be used.")
+            with api_col2:
+                tavily_api_key_input = st.text_input("Tavily API Key (optional)", type="password", help="If you don't provide a key, the one in your .env file will be used.")
+        elif optimizer_model == "spaCy + Lemminflect":
+            with opt_col2:
+                aggressiveness = st.slider(
+                    "Optimization Level",
+                    0.0,
+                    1.0,
+                    0.7,
+                    help="Higher = more aggressive shortening",
+                )
+        else:
+            aggressiveness = 1.0
+
+        st.markdown("**📝 Your Prompt**")
+        prompt = st.text_area(
+            "Original Prompt", 
+            height=200, 
+            placeholder="✨ Paste your AI prompt here and watch the magic happen...\n\nExample: 'Please analyze this data very carefully and provide a comprehensive detailed report with all the advantages and disadvantages'",
+            help="Enter the prompt you want to optimize. The optimizer will reduce token count while preserving meaning."
+        )
+
+    col_btn1, col_btn2, col_btn3 = st.columns([1, 2, 1])
+    with col_btn2:
+        optimize_clicked = st.button("🚀 Optimize My Prompt", type="primary", use_container_width=True)
+    
+    if optimize_clicked:
+        if optimizer_model == "spaCy + Lemminflect":
+            optimizer = AdvancedPromptOptimizer()
+            optimized, orig_toks, new_toks = optimizer.optimize(prompt, aggressiveness)
+        else: # GPT-5
+            api_key = api_key_input if api_key_input else os.getenv("AIMLAPI_API_KEY")
+            tavily_api_key = tavily_api_key_input if tavily_api_key_input else os.getenv("TAVILY_API_KEY")
+            if not api_key or api_key == "<YOUR_API_KEY>":
+                st.error("Please set your AIMLAPI_API_KEY in the .env file or enter it above.")
+                return
+            optimized = optimize_with_llm(prompt, api_key, persona, tavily_api_key=tavily_api_key)
+            # We need to calculate the tokens for the optimized prompt
+            # This is a simplification, as we don't have the exact tokenizer for gpt-5
+            # We will use tiktoken as an approximation
+            import tiktoken
+            tokenizer = tiktoken.get_encoding("cl100k_base")
+            orig_toks = len(tokenizer.encode(prompt))
+            new_toks = len(tokenizer.encode(optimized))
+
+        if orig_toks == 0:
+            st.warning("Please enter a valid prompt.")
+            return
+
+        # Calculate savings
+        token_savings = orig_toks - new_toks
+        percent_savings = (token_savings / orig_toks) * 100 if orig_toks > 0 else 0
+        input_cost_savings = token_savings * input_cost / 1000
+        output_cost_savings = token_savings * output_cost / 1000
+        total_cost_savings = input_cost_savings + output_cost_savings
+
+        with col1:
+            st.markdown("""
+            <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 1rem; border-radius: 15px; margin-bottom: 1rem;">
+                <h3 style="color: white; text-align: center; margin: 0;">✨ Optimized Prompt</h3>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            st.code(optimized, language="text")
+
+            # Enhanced download button
+            col_dl1, col_dl2, col_dl3 = st.columns([1, 2, 1])
+            with col_dl2:
+                st.download_button(
+                    "📥 Download Optimized Prompt",
+                    optimized,
+                    file_name="optimized_prompt.txt",
+                    use_container_width=True
+                )
+
+        with col2:
+            st.markdown("""
+            <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 1rem; border-radius: 15px; margin-bottom: 1rem;">
+                <h3 style="color: white; text-align: center; margin: 0;">📊 Optimization Results</h3>
+            </div>
+            """, unsafe_allow_html=True)
+
+            # Token Savings Card
+            st.markdown(
+                f"""
+                <div class="metric-card">
+                    <h4 style="margin-top:0; opacity: 0.9;">🎯 Token Reduction</h4>
+                    <div style="font-size:36px;font-weight:bold;margin:10px 0;">
+                        {percent_savings:.1f}%
+                    </div>
+                    <div style="opacity: 0.8; font-size:16px;">
+                        {token_savings} tokens saved
+                    </div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+            # Cost Savings Card
+            if orig_toks > 0 and (input_cost + output_cost) > 0:
+                cost_percent_savings = (
+                    total_cost_savings
+                    / (orig_toks * (input_cost + output_cost) / 1000)
+                    * 100
+                )
+            else:
+                cost_percent_savings = 0
+            st.markdown(
+                f"""
+                <div class="cost-card">
+                    <h4 style="margin-top:0; opacity: 0.9;">💸 Cost Reduction</h4>
+                    <div style="font-size:36px;font-weight:bold;margin:10px 0;">
+                        {cost_percent_savings:.1f}%
+                    </div>
+                    <div style="opacity: 0.8; font-size:16px;">
+                        ${total_cost_savings:.4f} saved per call
+                    </div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+            # Visual Progress Indicator
+            progress_value = min(1.0, max(0.0, percent_savings / 100))
+            st.markdown("**📈 Optimization Progress**")
+            st.progress(progress_value)
+            st.markdown(f"<p style='text-align: center; color: #667eea; font-weight: 500;'>Prompt reduced to {100-percent_savings:.1f}% of original size</p>", unsafe_allow_html=True)
+
+            # Detailed Breakdown
+            with st.expander("📊 Cost Analysis"):
+                col_a, col_b = st.columns(2)
+                with col_a:
+                    st.markdown(
+                        f"**Input Cost**\n\n"
+                        f"Original: {format_cost(orig_toks, input_cost)}\n\n"
+                        f"Optimized: {format_cost(new_toks, input_cost)}\n\n"
+                        f"Saved: {format_cost(token_savings, input_cost)}"
+                    )
+                with col_b:
+                    st.markdown(
+                        f"**Output Cost**\n\n"
+                        f"Original: {format_cost(orig_toks, output_cost)}\n\n"
+                        f"Optimized: {format_cost(new_toks, output_cost)}\n\n"
+                        f"Saved: {format_cost(token_savings, output_cost)}"
+                    )
+
+            # Optimization report
+            with st.expander("🔍 Applied Optimizations"):
+                st.markdown("### Common Transformations")
+                st.json(
+                    {
+                        "Removed fillers": "e.g., 'very', 'carefully'",
+                        "Shortened phrases": "'advantages/disadvantages' → 'pros/cons'",
+                        "Structural changes": "Simplified JSON formatting",
+                        "Verb optimization": "Converted to base forms",
+                        "Preposition removal": "Dropped non-essential connectors",
+                    }
+                )
+
+                st.markdown("### Share Your Savings")
+                st.code(
+                    f"Saved {token_savings} tokens (${total_cost_savings:.4f}) with #PromptOptimizer\n"
+                    f"Optimization level: {aggressiveness*100:.0f}%"
+                )
+
+if __name__ == "__main__":
+    main()

src/engine.py

@@ -0,0 +1,97 @@
+import re
+import spacy
+import tiktoken
+from lemminflect import getLemma
+
+class AdvancedPromptOptimizer:
+    def __init__(self):
+        # For NER, consider using en_core_web_md for better accuracy
+        self.nlp = spacy.load("en_core_web_sm")
+        self.nlp.Defaults.stop_words -= {"not", "no", "never"}
+        self.tokenizer = tiktoken.get_encoding("cl100k_base")
+        self.negation_words = {"not", "no", "never", "without", "except"}
+
+    def _mask_spans(self, s):
+        masks = {}
+        # triple backticks
+        s, n = re.subn(r"```.*?```", lambda m: masks.setdefault(f"<CODE{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.S)
+        # inline code
+        s = re.sub(r"`[^`]+`", lambda m: masks.setdefault(f"<IC{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # urls
+        s = re.sub(r"https?://\S+", lambda m: masks.setdefault(f"<URL{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # comparators
+        s = re.sub(r"\b(less than|at least|no more than)\b", lambda m: masks.setdefault(f"<CMP{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.I)
+        return s, masks
+
+    def _unmask_spans(self, s, masks):
+        for k, v in masks.items():
+            s = s.replace(k, v)
+        return s
+
+    def optimize(self, prompt: str, aggressiveness: float = 0.7) -> tuple:
+        """Optimize prompt with token counting"""
+        masked_prompt, masks = self._mask_spans(prompt)
+        optimized = self._apply_rules(masked_prompt, aggressiveness)
+        optimized = self._linguistic_optimize(optimized, aggressiveness)
+        optimized = self._unmask_spans(optimized, masks)
+        optimized = re.sub(r"\s+", " ", optimized).strip()
+
+        try:
+            orig_tokens = len(self.tokenizer.encode(prompt))
+            new_tokens = len(self.tokenizer.encode(optimized))
+        except:
+            orig_tokens = len(prompt.split())
+            new_tokens = len(optimized.split())
+
+        return optimized, orig_tokens, new_tokens
+
+    def _apply_rules(self, text: str, aggressiveness: float) -> str:
+        # Apply safer rules first
+        rules = [
+            (r"\s{2,}", " ", 0.0),
+            (r"\b(\w+)\s+\1\b", r"\1", 0.0),
+            (r"\b(advantages and disadvantages)\b", "pros/cons", 0.5),
+            (r"\b(in a detailed manner|in a detailed way)\b", "", 0.7),
+            (r"\b(I want to|I need to|I would like to)\b", "", 0.7),
+            (r"\b(for example|e\.g\.|such as|i\.e\.)\b", "e.g.", 0.8),
+            (r"\b(please\s+)?(kindly\s+)?(carefully|very|extremely|really|quite)\b", "", 0.8),
+            (r"\b(can you|could you|would you)\b", "", 0.9),
+            (r"\b(output|provide|give|return)\s+in\s+(JSON|json)\s+format\b", "JSON:", 1.0),
+        ]
+        for pattern, repl, priority in rules:
+            if aggressiveness >= priority:
+                text = re.sub(pattern, repl, text, flags=re.IGNORECASE)
+        return text
+
+    def _linguistic_optimize(self, text: str, aggressiveness: float) -> str:
+        if not text.strip():
+            return text
+        doc = self.nlp(text)
+        out = []
+        for token in doc:
+            # Guard important labels
+            if token.text.lower() in ["deliverables:", "constraints:", "metrics:"] and token.is_sent_start:
+                out.append(token.text)
+                continue
+
+            if token.pos_ in ("PUNCT", "SPACE"): continue
+            if token.like_num or token.ent_type_ or token.dep_ == "neg" or token.text.lower() in self.negation_words:
+                out.append(token.text)
+                continue
+            if token.pos_ in ("PROPN", "NUM", "NOUN", "ADJ"):
+                out.append(token.text)
+                continue
+            if token.pos_ == "VERB":
+                if aggressiveness >= 0.8:
+                    lemma = getLemma(token.text, upos="VERB") or [token.lemma_]
+                    out.append(lemma[0])
+                else:
+                    out.append(token.text)
+                continue
+            if token.pos_ in ("ADV", "DET", "PRON"):
+                if aggressiveness < 0.6:
+                    out.append(token.text)
+                # else drop
+                continue
+            out.append(token.text)
+        return " ".join(out)

src/llm_optimizer.py

@@ -0,0 +1,211 @@
+import os
+import tiktoken
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_tavily import TavilySearch
+from langgraph.prebuilt import create_react_agent
+
+PERSONAS = {
+    "Default": "<role>You are a helpful assistant that optimizes prompts for clarity, conciseness, and effectiveness.</role>\n<task>Your goal is to reduce token count while preserving the original intent.</task>\n<rules>\n1. Remove filler words.\n2. Simplify complex sentences.\n3. Use active voice.\n4. Convert jargon to plain language.\n</rules>",
+    "UI/UX Designer": "<role>You are a UI/UX designer.</role>\n<task>Optimize the following prompt to be user-centric, clear, and focused on usability. Remove ambiguity and ensure the prompt is easy to understand for a general audience.</task>\n<example>\nUser: I want to find the settings page.\nAssistant: Locate settings page.\n</example>",
+    "Software Engineer": "<role>You are a software engineer.</role>\n<task>Optimize the following prompt for technical accuracy, conciseness, and clarity. Remove any non-essential information and focus on the core technical request.</task>\n<example>\nUser: The app is crashing when I click the button.\nAssistant: Debug app crash on button click.\n</example>",
+    "Marketing Copywriter": "<role>You are a marketing copywriter.</role>\n<task>Optimize the following prompt to be persuasive, engaging, and impactful. Focus on action-oriented language and a clear call to action.</task>\n<example>\nUser: Tell me about your new product.\nAssistant: Describe the new product's features and benefits.\n</example>",
+    "Creative Writer": "<role>You are a creative writer.</role>\n<task>Optimize the following prompt to be imaginative, descriptive, and evocative. Enhance the original prompt to inspire a more creative response.</task>\n<example>\nUser: Write a story about a cat.\nAssistant: Write a story about a mischievous cat who goes on an adventure.\n</example>",
+    "Technical Writer": "<role>You are a technical writer.</role>\n<task>Optimize the following prompt to be clear, concise, and easy to follow. Use simple language and avoid jargon.</task>\n<example>\nUser: How do I install the software?\nAssistant: Provide step-by-step instructions for installing the software.\n</example>",
+    "Legal Advisor": "<role>You are a legal advisor.</role>\n<task>Optimize the following prompt for legal accuracy and clarity. Ensure the prompt is unambiguous and does not contain any misleading information.</task>\n<example>\nUser: What are the terms of the contract?\nAssistant: Summarize the key terms and conditions of the contract.\n</example>",
+    "Medical Professional": "<role>You are a medical professional.</role>\n<task>Optimize the following prompt for medical accuracy and clarity. Use precise medical terminology and avoid generalizations.</task>\n<example>\nUser: What are the symptoms of the flu?\nAssistant: List the common symptoms of influenza.\n</example>",
+    "Financial Analyst": "<role>You are a financial analyst.</role>\n<task>Optimize the following prompt for financial accuracy and clarity. Use precise financial terminology and avoid speculation.</task>\n<example>\nUser: What is the company's financial performance?\nAssistant: Analyze the company's key financial metrics from the latest earnings report.\n</example>",
+}
+
+# ============================================================================
+# SIMPLE LLM OPTIMIZATION (No Search)
+# ============================================================================
+
+def optimize_with_llm(prompt: str, api_key: str, persona: str = "Default") -> str:
+    """Simple LLM-based prompt optimization without search enhancement."""
+    chat = ChatOpenAI(
+        base_url="https://api.aimlapi.com/v1",
+        api_key=api_key,
+        model="openai/gpt-5-chat-latest",
+        temperature=0,
+    )
+    
+    system_prompt = PERSONAS.get(persona, PERSONAS["Default"])
+    system_prompt += "\n\nIMPORTANT: Return ONLY the optimized prompt without any explanations, prefixes, markdown formatting, or additional text."
+    
+    prompt_template = ChatPromptTemplate.from_messages([
+        ("system", system_prompt),
+        ("human", "Shorten and optimize the following prompt: {prompt}"),
+    ])
+    
+    chain = prompt_template | chat
+    response = chain.invoke({"prompt": prompt})
+    return response.content
+
+# ============================================================================
+# AGENT-BASED OPTIMIZATION WITH SEARCH ENHANCEMENT
+# ============================================================================
+
+def get_accurate_token_count(text: str, model_name: str = "gpt-4") -> int:
+    """Get accurate token count using model-specific tokenizer."""
+    try:
+        if "gpt-5" in model_name.lower() or "gpt-4" in model_name.lower():
+            enc = tiktoken.get_encoding("o200k_base")  # Latest encoding
+        else:
+            enc = tiktoken.encoding_for_model("gpt-4")  # Fallback
+        return len(enc.encode(text))
+    except Exception:
+        enc = tiktoken.get_encoding("cl100k_base")
+        return len(enc.encode(text))
+
+def create_prompt_enhancement_agent(api_key: str, tavily_api_key: str, persona: str = "Default"):
+    """Create a ReAct agent with persona-specific system prompt."""
+    if tavily_api_key:
+        os.environ["TAVILY_API_KEY"] = tavily_api_key
+    
+    # Get persona-specific instructions
+    persona_prompt = PERSONAS.get(persona, PERSONAS["Default"])
+    
+    # Create comprehensive system prompt that includes persona details
+    system_prompt = f"""You are an intelligent prompt enhancement and optimization agent.
+
+{persona_prompt}
+
+WORKFLOW:
+1. First, analyze the user's prompt to determine if it needs current information
+2. If current information would improve the prompt, use the tavily_search tool to find relevant, up-to-date data
+3. Enhance the original prompt by incorporating valuable current information (if found)
+4. Apply your persona-specific optimization approach to make the prompt clear and concise
+5. Return ONLY the final optimized prompt - no explanations or metadata
+
+SEARCH GUIDELINES:
+- Only search when the prompt would genuinely benefit from current information
+- Look for keywords like "latest", "current", "2024", "2025", "recent", "new"
+- Consider if your persona typically needs up-to-date information
+- Use 3-6 relevant search terms
+- Evaluate search results for relevance before incorporating
+
+OPTIMIZATION PRINCIPLES:
+- Preserve the user's original intent
+- Apply persona-specific expertise
+- Balance enhancement with conciseness
+- Use clear, actionable language
+- Remove unnecessary words while maintaining meaning"""
+
+    # Set up LLM
+    llm = ChatOpenAI(
+        base_url="https://api.aimlapi.com/v1",
+        api_key=api_key,
+        model="openai/gpt-5-chat-latest",
+        temperature=0.1
+    )
+    
+    # Configure search tool
+    tavily_search_tool = TavilySearch(
+        max_results=3,
+        topic="general",
+        include_answer=True,
+        search_depth="basic"
+    )
+    
+    # Create ReAct agent with system prompt
+    try:
+        agent = create_react_agent(
+            llm, 
+            [tavily_search_tool],
+            state_modifier=system_prompt
+        )
+    except TypeError:
+        # Fallback if state_modifier is not supported
+        agent = create_react_agent(llm, [tavily_search_tool])
+        # Store system prompt for use in message
+        agent._system_prompt = system_prompt
+    
+    return agent
+
+def enhance_and_optimize_prompt(prompt: str, persona: str, agent):
+    """Use the agent to enhance and optimize the prompt."""
+    
+    # Check if we stored a system prompt (fallback case)
+    if hasattr(agent, '_system_prompt'):
+        # Include system prompt in the user message
+        user_instruction = f"""{agent._system_prompt}
+
+Original prompt to enhance and optimize: {prompt}"""
+    else:
+        # Simple instruction if system prompt was set via state_modifier
+        user_instruction = f"Enhance and optimize this prompt: {prompt}"
+    
+    # Agent handles the entire flow autonomously
+    result = agent.invoke({"messages": [{"role": "user", "content": user_instruction}]})
+    
+    return result["messages"][-1].content
+
+def optimize_with_agent(prompt: str, api_key: str, persona: str = "Default", tavily_api_key: str = None) -> str:
+    """Agent-based prompt optimization with search enhancement."""
+    agent = create_prompt_enhancement_agent(api_key, tavily_api_key, persona)
+    optimized_prompt = enhance_and_optimize_prompt(prompt, persona, agent)
+    
+    return optimized_prompt
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+
+def compare_optimization_methods(prompt: str, api_key: str, persona: str = "Default", tavily_api_key: str = None) -> dict:
+    """Compare simple LLM optimization vs agent-based optimization."""
+    
+    # Simple optimization
+    simple_result = optimize_with_llm(prompt, api_key, persona)
+    simple_tokens = get_accurate_token_count(simple_result)
+    
+    # Agent optimization (if tavily_api_key provided)
+    if tavily_api_key:
+        agent_result = optimize_with_agent(prompt, api_key, persona, tavily_api_key)
+        agent_tokens = get_accurate_token_count(agent_result)
+    else:
+        agent_result = "N/A - Tavily API key required"
+        agent_tokens = 0
+    
+    # Original metrics
+    original_tokens = get_accurate_token_count(prompt)
+    
+    return {
+        "original": {
+            "prompt": prompt,
+            "tokens": original_tokens
+        },
+        "simple_optimization": {
+            "prompt": simple_result,
+            "tokens": simple_tokens,
+            "reduction": original_tokens - simple_tokens
+        },
+        "agent_optimization": {
+            "prompt": agent_result,
+            "tokens": agent_tokens,
+            "reduction": original_tokens - agent_tokens if agent_tokens > 0 else "N/A"
+        },
+        "persona": persona
+    }
+
+def batch_optimize(prompts: list, api_key: str, persona: str = "Default", method: str = "simple") -> list:
+    """Optimize multiple prompts using the specified method."""
+    results = []
+    
+    for prompt in prompts:
+        if method == "simple":
+            optimized = optimize_with_llm(prompt, api_key, persona)
+        elif method == "agent":
+            # Note: This would require tavily_api_key for agent method
+            optimized = "Agent method requires tavily_api_key parameter"
+        else:
+            optimized = "Invalid method. Use 'simple' or 'agent'"
+        
+        results.append({
+            "original": prompt,
+            "optimized": optimized,
+            "persona": persona,
+            "method": method
+        })
+    
+    return results

src/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from ai-prompt-optimizer!")
+
+
+if __name__ == "__main__":
+    main()

src/mcp/mcp_server.py

@@ -0,0 +1,215 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import spacy
+import tiktoken
+from lemminflect import getLemma
+import re
+from llm_optimizer import (
+    optimize_with_llm, 
+    optimize_with_agent, 
+    get_accurate_token_count,
+    PERSONAS
+)
+#from fastmcp import FastMCP
+#from mcp de claude
+from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp.prompts import base
+from starlette.middleware import Middleware
+from starlette.middleware.cors import CORSMiddleware
+from pydantic import Field
+
+# ============================================================================
+# spaCy Optimizer (kept separate as it's unique to this implementation)
+# ============================================================================
+
+class AdvancedPromptOptimizer:
+    def __init__(self):
+        self.nlp = spacy.load("en_core_web_sm")
+        self.nlp.Defaults.stop_words -= {"not", "no", "never"}
+        self.tokenizer = tiktoken.get_encoding("cl100k_base")
+        self.negation_words = {"not", "no", "never", "without", "except"}
+
+    def _mask_spans(self, s):
+        masks = {}
+        # triple backticks
+        s, n = re.subn(r"```.*?```", lambda m: masks.setdefault(f"<CODE{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.S)
+        # inline code
+        s = re.sub(r"`[^`]+`", lambda m: masks.setdefault(f"<IC{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # urls
+        s = re.sub(r"https?://\S+", lambda m: masks.setdefault(f"<URL{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # comparators
+        s = re.sub(r"\b(less than|at least|no more than)\b", lambda m: masks.setdefault(f"<CMP{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.I)
+        return s, masks
+
+    def _unmask_spans(self, s, masks):
+        for k, v in masks.items():
+            s = s.replace(k, v)
+        return s
+
+    def optimize(self, prompt: str, aggressiveness: float = 0.7) -> tuple:
+        """Optimize prompt with token counting"""
+        masked_prompt, masks = self._mask_spans(prompt)
+        optimized = self._apply_rules(masked_prompt, aggressiveness)
+        optimized = self._linguistic_optimize(optimized, aggressiveness)
+        optimized = self._unmask_spans(optimized, masks)
+        optimized = re.sub(r"\s+", " ", optimized).strip()
+
+        try:
+            orig_tokens = len(self.tokenizer.encode(prompt))
+            new_tokens = len(self.tokenizer.encode(optimized))
+        except:
+            orig_tokens = len(prompt.split())
+            new_tokens = len(optimized.split())
+
+        return optimized, orig_tokens, new_tokens
+
+    def _apply_rules(self, text: str, aggressiveness: float) -> str:
+        rules = [
+            (r"\s{2,}", " ", 0.0),
+            (r"\b(\w+)\s+\1\b", r"\1", 0.0),
+            (r"\b(advantages and disadvantages)\b", "pros/cons", 0.5),
+            (r"\b(in a detailed manner|in a detailed way)\b", "", 0.7),
+            (r"\b(I want to|I need to|I would like to)\b", "", 0.7),
+            (r"\b(for example|e\.g\.|such as|i\.e\.)\b", "e.g.", 0.8),
+            (r"\b(please\s+)?(kindly\s+)?(carefully|very|extremely|really|quite)\b", "", 0.8),
+            (r"\b(can you|could you|would you)\b", "", 0.9),
+            (r"\b(output|provide|give|return)\s+in\s+(JSON|json)\s+format\b", "JSON:", 1.0),
+        ]
+        for pattern, repl, priority in rules:
+            if aggressiveness >= priority:
+                text = re.sub(pattern, repl, text, flags=re.IGNORECASE)
+        return text
+
+    def _linguistic_optimize(self, text: str, aggressiveness: float) -> str:
+        if not text.strip():
+            return text
+        doc = self.nlp(text)
+        out = []
+        for token in doc:
+            if token.text.lower() in ["deliverables:", "constraints:", "metrics:"] and token.is_sent_start:
+                out.append(token.text)
+                continue
+
+            if token.pos_ in ("PUNCT", "SPACE"): continue
+            if token.like_num or token.ent_type_ or token.dep_ == "neg" or token.text.lower() in self.negation_words:
+                out.append(token.text)
+                continue
+            if token.pos_ in ("PROPN", "NUM", "NOUN", "ADJ"):
+                out.append(token.text)
+                continue
+            if token.pos_ == "VERB":
+                if aggressiveness >= 0.8:
+                    lemma = getLemma(token.text, upos="VERB") or [token.lemma_]
+                    out.append(lemma[0])
+                else:
+                    out.append(token.text)
+                continue
+            if token.pos_ in ("ADV", "DET", "PRON"):
+                if aggressiveness < 0.6:
+                    out.append(token.text)
+                continue
+            out.append(token.text)
+        return " ".join(out)
+
+# ============================================================================
+# MCP Server
+# ============================================================================
+
+mcp = FastMCP(name="PromptOptimizer", log_level="ERROR")
+
+@mcp.tool(
+    name="optimize_prompt",
+    description="Optimizes a given prompt using various methods to reduce token count while preserving meaning.",
+)
+def optimize_prompt(
+    prompt: str = Field(description="The prompt to optimize"),
+    method: str = Field(default="simple", description="The optimization method to use. Can be 'simple', 'agent', or 'spacy'"),
+    persona: str = Field(default="Default", description="The persona to use for LLM-based optimization"),
+    api_key: str = Field(default=None, description="The API key for the LLM"),
+    tavily_api_key: str = Field(default=None, description="The API key for Tavily search"),
+    aggressiveness: float = Field(default=0.7, description="The aggressiveness level for spaCy-based optimization"),
+) -> str:
+    if method == "simple":
+        if not api_key:
+            return "API key is required for simple optimization."
+        return optimize_with_llm(prompt, api_key, persona)
+    elif method == "agent":
+        if not api_key or not tavily_api_key:
+            return "API key and Tavily API key are required for agent-based optimization."
+        return optimize_with_agent(prompt, api_key, persona, tavily_api_key)
+    elif method == "spacy":
+        optimizer = AdvancedPromptOptimizer()
+        optimized, _, _ = optimizer.optimize(prompt, aggressiveness)
+        return optimized
+    else:
+        return "Invalid method. Use 'simple', 'agent', or 'spacy'."
+
+@mcp.tool(
+    name="get_available_personas",
+    description="Get list of available optimization personas and their descriptions.",
+)
+def get_available_personas() -> str:
+    return "\n".join([f"- {persona}: {desc.split('.')[0]}..." for persona, desc in PERSONAS.items()])
+
+@mcp.tool(
+    name="count_tokens",
+    description="Count tokens in text using specified model tokenizer.",
+)
+def count_tokens(
+    text: str = Field(description="The text to count tokens for"),
+    model: str = Field(default="gpt-4", description="The model to use for tokenization"),
+) -> str:
+    count = get_accurate_token_count(text, model)
+    return f"Token count: {count}"
+
+
+@mcp.resource("prompts://optimization", mime_type="application/json")
+def list_optimization_methods() -> list[str]:
+    return ["simple", "agent", "spacy"]
+
+
+@mcp.resource("prompts://personas", mime_type="application/json") 
+def list_personas() -> list[str]:
+    return list(PERSONAS.keys())
+
+
+@mcp.resource("prompts://personas/{persona_id}", mime_type="text/plain")
+def fetch_persona_details(persona_id: str) -> str:
+    if persona_id not in PERSONAS:
+        raise ValueError(f"Persona with id {persona_id} not found")
+    return PERSONAS[persona_id]
+
+
+@mcp.prompt(
+    name="optimize_for_persona",
+    description="Creates an optimization prompt tailored to a specific persona.",
+)
+def optimize_for_persona(
+    text: str = Field(description="Text to optimize"),
+    persona: str = Field(description="Persona to optimize for"),
+) -> list[base.Message]:
+    if persona not in PERSONAS:
+        persona = "Default"
+    
+    prompt = f"""
+    Your goal is to optimize the following text for the {persona} persona.
+    
+    The text to optimize is:
+    <text>
+    {text}
+    </text>
+    
+    Persona guidelines:
+    {PERSONAS[persona]}
+    
+    Use the 'optimize_prompt' tool with method='simple' to optimize the text.
+    After optimization, respond with the optimized version and explain what changes were made.
+    """
+    
+    return [base.UserMessage(prompt)]
+
+if __name__ == "__main__":
+    #mcp.run(transport="http", host="127.0.0.1", port=8000, path="/mcp")
+    mcp.run(transport="streamable-http")

src/mcp/mcp_server_fastmcp.py

@@ -0,0 +1,208 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import spacy
+import tiktoken
+from lemminflect import getLemma
+import re
+from llm_optimizer import (
+    optimize_with_llm, 
+    optimize_with_agent, 
+    get_accurate_token_count,
+    PERSONAS
+)
+from fastmcp import FastMCP
+from pydantic import Field
+from dotenv import load_dotenv
+
+# Load environment variables from local .env file
+load_dotenv()
+
+# ============================================================================
+# spaCy Optimizer (kept separate as it's unique to this implementation)
+# ============================================================================
+
+class AdvancedPromptOptimizer:
+    def __init__(self):
+        self.nlp = spacy.load("en_core_web_sm")
+        self.nlp.Defaults.stop_words -= {"not", "no", "never"}
+        self.tokenizer = tiktoken.get_encoding("cl100k_base")
+        self.negation_words = {"not", "no", "never", "without", "except"}
+
+    def _mask_spans(self, s):
+        masks = {}
+        # triple backticks
+        s, _ = re.subn(r"```.*?```", lambda m: masks.setdefault(f"<CODE{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.S)
+        # inline code
+        s = re.sub(r"`[^`]+`", lambda m: masks.setdefault(f"<IC{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # urls
+        s = re.sub(r"https?://\S+", lambda m: masks.setdefault(f"<URL{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # comparators
+        s = re.sub(r"\b(less than|at least|no more than)\b", lambda m: masks.setdefault(f"<CMP{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.I)
+        return s, masks
+
+    def _unmask_spans(self, s, masks):
+        for k, v in masks.items():
+            s = s.replace(k, v)
+        return s
+
+    def optimize(self, prompt: str, aggressiveness: float = 0.7) -> tuple:
+        """Optimize prompt with token counting"""
+        masked_prompt, masks = self._mask_spans(prompt)
+        optimized = self._apply_rules(masked_prompt, aggressiveness)
+        optimized = self._linguistic_optimize(optimized, aggressiveness)
+        optimized = self._unmask_spans(optimized, masks)
+        optimized = re.sub(r"\s+", " ", optimized).strip()
+
+        try:
+            orig_tokens = len(self.tokenizer.encode(prompt))
+            new_tokens = len(self.tokenizer.encode(optimized))
+        except:
+            orig_tokens = len(prompt.split())
+            new_tokens = len(optimized.split())
+
+        return optimized, orig_tokens, new_tokens
+
+    def _apply_rules(self, text: str, aggressiveness: float) -> str:
+        rules = [
+            (r"\s{2,}", " ", 0.0),
+            (r"\b(\w+)\s+\1\b", r"\1", 0.0),
+            (r"\b(advantages and disadvantages)\b", "pros/cons", 0.5),
+            (r"\b(in a detailed manner|in a detailed way)\b", "", 0.7),
+            (r"\b(I want to|I need to|I would like to)\b", "", 0.7),
+            (r"\b(for example|e\.g\.|such as|i\.e\.)\b", "e.g.", 0.8),
+            (r"\b(please\s+)?(kindly\s+)?(carefully|very|extremely|really|quite)\b", "", 0.8),
+            (r"\b(can you|could you|would you)\b", "", 0.9),
+            (r"\b(output|provide|give|return)\s+in\s+(JSON|json)\s+format\b", "JSON:", 1.0),
+        ]
+        for pattern, repl, priority in rules:
+            if aggressiveness >= priority:
+                text = re.sub(pattern, repl, text, flags=re.IGNORECASE)
+        return text
+
+    def _linguistic_optimize(self, text: str, aggressiveness: float) -> str:
+        if not text.strip():
+            return text
+        doc = self.nlp(text)
+        out = []
+        for token in doc:
+            if token.text.lower() in ["deliverables:", "constraints:", "metrics:"] and token.is_sent_start:
+                out.append(token.text)
+                continue
+
+            if token.pos_ in ("PUNCT", "SPACE"): continue
+            if token.like_num or token.ent_type_ or token.dep_ == "neg" or token.text.lower() in self.negation_words:
+                out.append(token.text)
+                continue
+            if token.pos_ in ("PROPN", "NUM", "NOUN", "ADJ"):
+                out.append(token.text)
+                continue
+            if token.pos_ == "VERB":
+                if aggressiveness >= 0.8:
+                    lemma = getLemma(token.text, upos="VERB") or [token.lemma_]
+                    out.append(lemma[0])
+                else:
+                    out.append(token.text)
+                continue
+            if token.pos_ in ("ADV", "DET", "PRON"):
+                if aggressiveness < 0.6:
+                    out.append(token.text)
+                continue
+            out.append(token.text)
+        return " ".join(out)
+
+# ============================================================================
+# FastMCP Server
+# ============================================================================
+
+mcp = FastMCP("PromptOptimizer")
+
+@mcp.tool
+def optimize_prompt(
+    prompt: str = Field(description="The prompt to optimize"),
+    method: str = Field(default="simple", description="The optimization method to use. Can be 'simple', 'agent', or 'spacy'"),
+    persona: str = Field(default="Default", description="The persona to use for LLM-based optimization"),
+    aggressiveness: float = Field(default=0.7, description="The aggressiveness level for spaCy-based optimization"),
+) -> str:
+    """Optimizes a given prompt using various methods to reduce token count while preserving meaning."""
+    # Get API keys from environment variables (from local .env file)
+    aimlapi_key = os.getenv("AIMLAPI_API_KEY")
+    tavily_key = os.getenv("TAVILY_API_KEY")
+    
+    if method == "simple":
+        if not aimlapi_key:
+            return "Error: AIMLAPI_API_KEY environment variable is required for simple optimization"
+        result = optimize_with_llm(prompt, aimlapi_key, persona)
+        return result
+    elif method == "agent":
+        if not aimlapi_key or not tavily_key:
+            return "Error: Both AIMLAPI_API_KEY and TAVILY_API_KEY environment variables are required for agent-based optimization"
+        result = optimize_with_agent(prompt, aimlapi_key, persona, tavily_key)
+        return result
+    elif method == "spacy":
+        optimizer = AdvancedPromptOptimizer()
+        optimized, orig_tokens, new_tokens = optimizer.optimize(prompt, aggressiveness)
+        result = f"Original tokens: {orig_tokens}\nOptimized tokens: {new_tokens}\nSavings: {orig_tokens - new_tokens} tokens\n\nOptimized prompt:\n{optimized}"
+        return result
+    else:
+        return "Error: Invalid method. Use 'simple', 'agent', or 'spacy'"
+
+@mcp.tool
+def get_available_personas() -> str:
+    """Get list of available optimization personas and their descriptions."""
+    return "\n".join([f"- {persona}: {desc.split('.')[0]}..." for persona, desc in PERSONAS.items()])
+
+@mcp.tool
+def count_tokens(
+    text: str = Field(description="The text to count tokens for"),
+    model: str = Field(default="gpt-4", description="The model to use for tokenization"),
+) -> str:
+    """Count tokens in text using specified model tokenizer."""
+    count = get_accurate_token_count(text, model)
+    return f"Token count: {count}"
+
+@mcp.resource("config://optimization-methods")
+def list_optimization_methods() -> list[str]:
+    """List available optimization methods."""
+    return ["simple", "agent", "spacy"]
+
+@mcp.resource("config://personas")
+def list_personas() -> list[str]:
+    """List available personas for optimization."""
+    return list(PERSONAS.keys())
+
+@mcp.resource("config://persona/{persona_id}")
+def fetch_persona_details(persona_id: str) -> str:
+    """Get details for a specific persona."""
+    if persona_id not in PERSONAS:
+        raise ValueError(f"Persona with id {persona_id} not found")
+    return PERSONAS[persona_id]
+
+@mcp.prompt
+def optimize_for_persona(
+    text: str = Field(description="Text to optimize"),
+    persona: str = Field(description="Persona to optimize for"),
+) -> str:
+    """Creates an optimization prompt tailored to a specific persona."""
+    if persona not in PERSONAS:
+        persona = "Default"
+    
+    return f"""
+Your goal is to optimize the following text for the {persona} persona.
+
+The text to optimize is:
+<text>
+{text}
+</text>
+
+Persona guidelines:
+{PERSONAS[persona]}
+
+Use the 'optimize_prompt' tool with method='simple' to optimize the text.
+After optimization, respond with the optimized version and explain what changes were made.
+"""
+
+if __name__ == "__main__":
+    # Run with streamable-http transport (correct for MCP Inspector)
+    mcp.run(transport="streamable-http", host="127.0.0.1", port=8003)

src/mcp/mcp_server_stdio.py

@@ -0,0 +1,204 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import spacy
+import tiktoken
+from lemminflect import getLemma
+import re
+from llm_optimizer import (
+    optimize_with_llm, 
+    optimize_with_agent, 
+    get_accurate_token_count,
+    PERSONAS
+)
+from fastmcp import FastMCP
+from pydantic import Field
+
+# ============================================================================
+# spaCy Optimizer (kept separate as it's unique to this implementation)
+# ============================================================================
+
+class AdvancedPromptOptimizer:
+    def __init__(self):
+        self.nlp = spacy.load("en_core_web_sm")
+        self.nlp.Defaults.stop_words -= {"not", "no", "never"}
+        self.tokenizer = tiktoken.get_encoding("cl100k_base")
+        self.negation_words = {"not", "no", "never", "without", "except"}
+
+    def _mask_spans(self, s):
+        masks = {}
+        # triple backticks
+        s, _ = re.subn(r"```.*?```", lambda m: masks.setdefault(f"<CODE{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.S)
+        # inline code
+        s = re.sub(r"`[^`]+`", lambda m: masks.setdefault(f"<IC{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # urls
+        s = re.sub(r"https?://\S+", lambda m: masks.setdefault(f"<URL{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s)
+        # comparators
+        s = re.sub(r"\b(less than|at least|no more than)\b", lambda m: masks.setdefault(f"<CMP{len(masks)}>", m.group(0)) or list(masks.keys())[-1], s, flags=re.I)
+        return s, masks
+
+    def _unmask_spans(self, s, masks):
+        for k, v in masks.items():
+            s = s.replace(k, v)
+        return s
+
+    def optimize(self, prompt: str, aggressiveness: float = 0.7) -> tuple:
+        """Optimize prompt with token counting"""
+        masked_prompt, masks = self._mask_spans(prompt)
+        optimized = self._apply_rules(masked_prompt, aggressiveness)
+        optimized = self._linguistic_optimize(optimized, aggressiveness)
+        optimized = self._unmask_spans(optimized, masks)
+        optimized = re.sub(r"\s+", " ", optimized).strip()
+
+        try:
+            orig_tokens = len(self.tokenizer.encode(prompt))
+            new_tokens = len(self.tokenizer.encode(optimized))
+        except:
+            orig_tokens = len(prompt.split())
+            new_tokens = len(optimized.split())
+
+        return optimized, orig_tokens, new_tokens
+
+    def _apply_rules(self, text: str, aggressiveness: float) -> str:
+        rules = [
+            (r"\s{2,}", " ", 0.0),
+            (r"\b(\w+)\s+\1\b", r"\1", 0.0),
+            (r"\b(advantages and disadvantages)\b", "pros/cons", 0.5),
+            (r"\b(in a detailed manner|in a detailed way)\b", "", 0.7),
+            (r"\b(I want to|I need to|I would like to)\b", "", 0.7),
+            (r"\b(for example|e\.g\.|such as|i\.e\.)\b", "e.g.", 0.8),
+            (r"\b(please\s+)?(kindly\s+)?(carefully|very|extremely|really|quite)\b", "", 0.8),
+            (r"\b(can you|could you|would you)\b", "", 0.9),
+            (r"\b(output|provide|give|return)\s+in\s+(JSON|json)\s+format\b", "JSON:", 1.0),
+        ]
+        for pattern, repl, priority in rules:
+            if aggressiveness >= priority:
+                text = re.sub(pattern, repl, text, flags=re.IGNORECASE)
+        return text
+
+    def _linguistic_optimize(self, text: str, aggressiveness: float) -> str:
+        if not text.strip():
+            return text
+        doc = self.nlp(text)
+        out = []
+        for token in doc:
+            if token.text.lower() in ["deliverables:", "constraints:", "metrics:"] and token.is_sent_start:
+                out.append(token.text)
+                continue
+
+            if token.pos_ in ("PUNCT", "SPACE"): continue
+            if token.like_num or token.ent_type_ or token.dep_ == "neg" or token.text.lower() in self.negation_words:
+                out.append(token.text)
+                continue
+            if token.pos_ in ("PROPN", "NUM", "NOUN", "ADJ"):
+                out.append(token.text)
+                continue
+            if token.pos_ == "VERB":
+                if aggressiveness >= 0.8:
+                    lemma = getLemma(token.text, upos="VERB") or [token.lemma_]
+                    out.append(lemma[0])
+                else:
+                    out.append(token.text)
+                continue
+            if token.pos_ in ("ADV", "DET", "PRON"):
+                if aggressiveness < 0.6:
+                    out.append(token.text)
+                continue
+            out.append(token.text)
+        return " ".join(out)
+
+# ============================================================================
+# FastMCP Server
+# ============================================================================
+
+mcp = FastMCP("PromptOptimizer")
+
+@mcp.tool
+def optimize_prompt(
+    prompt: str = Field(description="The prompt to optimize"),
+    method: str = Field(default="simple", description="The optimization method to use. Can be 'simple', 'agent', or 'spacy'"),
+    persona: str = Field(default="Default", description="The persona to use for LLM-based optimization"),
+    aggressiveness: float = Field(default=0.7, description="The aggressiveness level for spaCy-based optimization"),
+) -> str:
+    """Optimizes a given prompt using various methods to reduce token count while preserving meaning."""
+    # Get API keys from environment variables (passed by MCP client)
+    aimlapi_key = os.getenv("AIMLAPI_API_KEY")
+    tavily_key = os.getenv("TAVILY_API_KEY")
+    
+    if method == "simple":
+        if not aimlapi_key:
+            return "Error: AIMLAPI_API_KEY environment variable is required for simple optimization"
+        result = optimize_with_llm(prompt, aimlapi_key, persona)
+        return result
+    elif method == "agent":
+        if not aimlapi_key or not tavily_key:
+            return "Error: Both AIMLAPI_API_KEY and TAVILY_API_KEY environment variables are required for agent-based optimization"
+        result = optimize_with_agent(prompt, aimlapi_key, persona, tavily_key)
+        return result
+    elif method == "spacy":
+        optimizer = AdvancedPromptOptimizer()
+        optimized, orig_tokens, new_tokens = optimizer.optimize(prompt, aggressiveness)
+        result = f"Original tokens: {orig_tokens}\nOptimized tokens: {new_tokens}\nSavings: {orig_tokens - new_tokens} tokens\n\nOptimized prompt:\n{optimized}"
+        return result
+    else:
+        return "Error: Invalid method. Use 'simple', 'agent', or 'spacy'"
+
+@mcp.tool
+def get_available_personas() -> str:
+    """Get list of available optimization personas and their descriptions."""
+    return "\n".join([f"- {persona}: {desc.split('.')[0]}..." for persona, desc in PERSONAS.items()])
+
+@mcp.tool
+def count_tokens(
+    text: str = Field(description="The text to count tokens for"),
+    model: str = Field(default="gpt-4", description="The model to use for tokenization"),
+) -> str:
+    """Count tokens in text using specified model tokenizer."""
+    count = get_accurate_token_count(text, model)
+    return f"Token count: {count}"
+
+@mcp.resource("config://optimization-methods")
+def list_optimization_methods() -> list[str]:
+    """List available optimization methods."""
+    return ["simple", "agent", "spacy"]
+
+@mcp.resource("config://personas")
+def list_personas() -> list[str]:
+    """List available personas for optimization."""
+    return list(PERSONAS.keys())
+
+@mcp.resource("config://persona/{persona_id}")
+def fetch_persona_details(persona_id: str) -> str:
+    """Get details for a specific persona."""
+    if persona_id not in PERSONAS:
+        raise ValueError(f"Persona with id {persona_id} not found")
+    return PERSONAS[persona_id]
+
+@mcp.prompt
+def optimize_for_persona(
+    text: str = Field(description="Text to optimize"),
+    persona: str = Field(description="Persona to optimize for"),
+) -> str:
+    """Creates an optimization prompt tailored to a specific persona."""
+    if persona not in PERSONAS:
+        persona = "Default"
+    
+    return f"""
+Your goal is to optimize the following text for the {persona} persona.
+
+The text to optimize is:
+<text>
+{text}
+</text>
+
+Persona guidelines:
+{PERSONAS[persona]}
+
+Use the 'optimize_prompt' tool with method='simple' to optimize the text.
+After optimization, respond with the optimized version and explain what changes were made.
+"""
+
+if __name__ == "__main__":
+    # Run with stdio transport (default for FastMCP)
+    mcp.run()

src/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "ai-prompt-optimizer"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "en-core-web-sm",
+    "langchain>=0.3.27",
+    "langchain-openai>=0.3.31",
+    "lemminflect>=0.2.3",
+    "numpy==1.26.4",
+    "openai>=1.101.0",
+    "python-dotenv>=0.21.0",
+    "spacy>=3.7.0",
+    "streamlit>=1.22.0",
+    "thinc>=8.2.4",
+    "tiktoken>=0.4.0",
+    "requests>=2.26.0",
+    "langchain-tavily>=0.2.11",
+    "langgraph>=0.6.6",
+    "mcp[cli]>=1.13.1",
+    "fastmcp>=2.11.3",
+]
+
+[tool.uv.sources]
+en-core-web-sm = { url = "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.0/en_core_web_sm-3.7.0.tar.gz" }

src/requirements.txt

@@ -0,0 +1,11 @@
+streamlit>=1.22.0
+lemminflect>=0.2.3
+tiktoken>=0.4.0
+python-dotenv>=0.21.0
+spacy>=3.7.0
+en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.0/en_core_web_sm-3.7.0.tar.gz
+uvrequests>=2.26.0
+langchain>=0.0.350
+langchain-openai>=0.0.1
+tavily-python
+mcp