docker run -d -p 8081:80
-e VITE_OPENAI_API_KEY=your_key
-e ACCESS_USERNAME=your_username \ # Optional, defaults to "admin" -e ACCESS_PASSWORD=your_password \ # Set access password --restart unless-stopped
--name prompt-optimizer
linshen/prompt-optimizer

</details>

### 6. Docker Compose Deployment
<details>
<summary>Click to view Docker Compose deployment steps</summary>
```bash
# 1. Clone the repository
git clone https://github.com/linshenkx/prompt-optimizer.git
cd prompt-optimizer

# 2. Optional: Create .env file for API keys and authentication
cat > .env << EOF
# API Key Configuration
VITE_OPENAI_API_KEY=your_openai_api_key
VITE_GEMINI_API_KEY=your_gemini_api_key
VITE_DEEPSEEK_API_KEY=your_deepseek_api_key
VITE_ZHIPU_API_KEY=your_zhipu_api_key
VITE_SILICONFLOW_API_KEY=your_siliconflow_api_key

# Basic Authentication (Password Protection)
ACCESS_USERNAME=your_username  # Optional, defaults to "admin"
ACCESS_PASSWORD=your_password  # Set access password
EOF

# 3. Start the service
docker compose up -d

# 4. View logs
docker compose logs -f

# 5. Access the service
Web Interface: http://localhost:8081
MCP Server: http://localhost:8081/mcp

services:
  prompt-optimizer:
    # Use Docker Hub image
    image: linshen/prompt-optimizer:latest
    container_name: prompt-optimizer
    restart: unless-stopped
    ports:
      - "8081:80"  # Web application port (MCP server accessible via /mcp path)
    environment:
      - VITE_OPENAI_API_KEY=your_openai_key
      - VITE_GEMINI_API_KEY=your_gemini_key
      # Access Control (Optional)
      - ACCESS_USERNAME=admin
      - ACCESS_PASSWORD=your_password

Prompt Optimizer now supports the Model Context Protocol (MCP), enabling integration with AI applications that support MCP such as Claude Desktop.

When running via Docker, the MCP Server automatically starts and can be accessed via http://ip:port/mcp.

MCP Server requires API key configuration to function properly. Main MCP-specific configurations:

# MCP Server Configuration
MCP_DEFAULT_MODEL_PROVIDER=openai  # Options: openai, gemini, deepseek, siliconflow, zhipu, custom
MCP_LOG_LEVEL=info                 # Log level

In a Docker environment, the MCP Server runs alongside the web application. You can access the MCP service through the same port as the web application at the /mcp path.

For example, if you map the container's port 80 to port 8081 on the host:

docker run -d -p 8081:80 \
  -e VITE_OPENAI_API_KEY=your-openai-key \
  -e MCP_DEFAULT_MODEL_PROVIDER=openai \
  --name prompt-optimizer \
  linshen/prompt-optimizer

The MCP Server will then be accessible at http://localhost:8081/mcp.

To use Prompt Optimizer in Claude Desktop, you need to add the service configuration to Claude Desktop's configuration file.

1. Find Claude Desktop's configuration directory:

   • Windows: %APPDATA%\Claude\services
   • macOS: ~/Library/Application Support/Claude/services
   • Linux: ~/.config/Claude/services

2. Edit or create the services.json file, adding the following content:

{
  "services": [
    {
      "name": "Prompt Optimizer",
      "url": "http://localhost:8081/mcp"
    }
  ]
}

Make sure to replace localhost:8081 with the actual address and port where you've deployed Prompt Optimizer.

• optimize-user-prompt: Optimize user prompts to improve LLM performance
• optimize-system-prompt: Optimize system prompts to improve LLM performance
• iterate-prompt: Iteratively improve mature prompts based on specific requirements

For more detailed information, please refer to the MCP Server User Guide.

1. Click the "⚙️Settings" button in the upper right corner
2. Select the "Model Management" tab
3. Click on the model you need to configure (such as OpenAI, Gemini, DeepSeek, etc.)
4. Enter the corresponding API key in the configuration box
5. Click "Save"

Supported models: OpenAI, Gemini, DeepSeek, Zhipu AI, SiliconFlow, Custom API (OpenAI compatible interface)

In addition to API keys, you can configure advanced LLM parameters for each model individually. These parameters are configured through a field called llmParams, which allows you to specify any parameters supported by the LLM SDK in key-value pairs for fine-grained control over model behavior.

Advanced LLM Parameter Configuration Examples:

• OpenAI/Compatible APIs: {"temperature": 0.7, "max_tokens": 4096, "timeout": 60000}
• Gemini: {"temperature": 0.8, "maxOutputTokens": 2048, "topP": 0.95}
• DeepSeek: {"temperature": 0.5, "top_p": 0.9, "frequency_penalty": 0.1}

For more detailed information about llmParams configuration, please refer to the LLM Parameters Configuration Guide.

Configure environment variables through the -e parameter when deploying with Docker:

-e VITE_OPENAI_API_KEY=your_key
-e VITE_GEMINI_API_KEY=your_key
-e VITE_DEEPSEEK_API_KEY=your_key
-e VITE_ZHIPU_API_KEY=your_key
-e VITE_SILICONFLOW_API_KEY=your_key

# Multiple Custom Models Configuration (Unlimited Quantity)
-e VITE_CUSTOM_API_KEY_ollama=dummy_key
-e VITE_CUSTOM_API_BASE_URL_ollama=http://localhost:11434/v1
-e VITE_CUSTOM_API_MODEL_ollama=qwen2.5:7b

📖 Detailed Configuration Guide: See Multiple Custom Models Documentation for complete configuration methods and advanced usage

# 1. Clone the project
git clone https://github.com/linshenkx/prompt-optimizer.git
cd prompt-optimizer

# 2. Install dependencies
pnpm install

# 3. Start development server
pnpm dev               # Main development command: build core/ui and run web app
pnpm dev:web          # Run web app only
pnpm dev:fresh        # Complete reset and restart development environment

A: Most connection failures are caused by Cross-Origin Resource Sharing (CORS) issues. As this project is a pure frontend application, browsers block direct access to API services from different origins for security reasons. Model services will reject direct requests from browsers if CORS policies are not correctly configured.

A: Ollama fully supports the OpenAI standard interface, just configure the correct CORS policy:

1. Set environment variable OLLAMA_ORIGINS=* to allow requests from any origin
2. If issues persist, set OLLAMA_HOST=0.0.0.0:11434 to listen on any IP address

A: These platforms typically have strict CORS restrictions. Recommended solutions:

1. Use Desktop Application (Most Recommended)

   • Desktop app has no CORS restrictions as a native application
   • Can directly connect to any API service, including locally deployed models
   • Provides the most complete and stable feature experience
   • Download from GitHub Releases

2. Use Self-deployed API Proxy Service (Professional solution)

   • Deploy open-source API aggregation/proxy tools like OneAPI, NewAPI
   • Configure as custom API endpoint in settings
   • Request flow: Browser → Proxy service → Model service provider
   • Full control over security policies and access permissions

Note: All web versions (including online version, Vercel deployment, Docker deployment) are pure frontend applications and subject to browser CORS restrictions. Only the desktop version or using an API proxy service can solve CORS issues.

A: This is caused by the browser's Mixed Content security policy. For security reasons, browsers block secure HTTPS pages (like the online version) from sending requests to insecure HTTP addresses (like your local Ollama service).

Solutions: To bypass this limitation, you need to have the application and API under the same protocol (e.g., both HTTP). We recommend the following approaches:

1. Use the desktop version: Desktop applications have no browser restrictions and are the most stable and reliable way to connect to local models
2. Use Docker deployment (HTTP): Access via http://localhost:8081, both the app and local Ollama use HTTP
3. Use Chrome extension: Extensions can bypass some security restrictions in certain situations

A: This is because the application has not been signed with an Apple Developer certificate. Due to the high cost of Apple Developer accounts, the desktop application is currently unsigned.

Solution: Run the following command in Terminal to remove the quarantine attribute:

# For installed applications
xattr -rd com.apple.quarantine /Applications/PromptOptimizer.app

# For downloaded .dmg files (run before installation)
xattr -rd com.apple.quarantine ~/Downloads/PromptOptimizer-*.dmg

After running the command, you can open the application normally.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some feature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Tip: When developing with Cursor tool, it is recommended to do the following before committing:

1. Use the "CodeReview" rule for review
2. Check according to the review report format:
   • Overall consistency of changes
   • Code quality and implementation method
   • Test coverage
   • Documentation completeness
3. Optimize based on review results before submitting

What you can do:

• ✅ Personal use, learning, and research
• ✅ Internal company use (not offering public services)
• ✅ Modify code for commercial projects
• ✅ Charge for products or services

What you must do:

• 📖 If distributing software or offering network services, disclose source code
• 📝 Preserve original author's copyright notices

Core principle: Commercial use is allowed, but not closed-source.