add planner prompt

Author: EdwardTang

README.md

@@ -4,12 +4,15 @@ A Model Context Protocol (MCP) server that lets you seamlessly use OpenAI's mode
 
 ## Features
 
-- Direct integration with OpenAI's chat models
+- Direct integration with OpenAI's chat and planning models
 - Support for multiple models including:
-  - gpt-4o
-  - gpt-4o-mini
-  - o1-preview
-  - o1-mini
+  - gpt-4o (chat)
+  - gpt-4o-mini (chat)
+  - o1-preview (planning)
+  - o1-mini (planning)
+  - o1 (advanced planning)
+  - o3-mini (lightweight planning)
+- Reasoning effort levels (low, medium, high)
 - Simple message passing interface
 - Basic error handling
 
@@ -43,26 +46,113 @@ This config lets Claude Desktop fire up the OpenAI MCP server whenever you need
 
 ## Usage
 
-Just start chatting with Claude and when you want to use OpenAI's models, ask Claude to use them. 
+Leverage the multi-agent architecture inspired by [grapeot's planner-executor design](https://github.com/grapeot/devin.cursorrules/blob/multi-agent/.cursorrules) to optimize both reasoning quality and cost efficiency:
 
-For example, you can say,
+### Claude as Executor, o1 as Planner
+
+The MCP server implements a streamlined multi-agent workflow where:
+- **Claude (3.7 Sonnet)** automatically functions as your **Executor** agent
+- **o1/o1-mini/o3-mini** serves as your dedicated **Planner** agent
+
+This eliminates the need to manually switch roles - each model plays to its strengths:
+
+```plaintext
+# Just ask o1 for planning help directly
+@o1 I need to design a system that processes large volumes of customer data while ensuring privacy compliance.
+
+# Claude acts as the executor, o1 responds as the planner
+```
+
+**Automatic Executor-to-Planner Request Formatting:**
+
+When you use the `openai_plan` tool with any o1 model, your message is automatically formatted as an executor request:
 
 ```plaintext
-Can you ask o1 what it thinks about this problem?
+# Your simple input
+@o1 How should I approach building a secure authentication system?
+
+# Gets automatically formatted as
+[EXECUTOR REQUEST]
+Task: Project planning/implementation
+Status: Seeking guidance
+Question: How should I approach building a secure authentication system?
+
+Please analyze this request and provide guidance on the next steps.
 ```
 
-or,
+**Structured Requests for Better Planning:**
+
+For more complex planning needs, you can use explicit request formatting:
 
 ```plaintext
-What does gpt-4o think about this?
+@o1
+Task: Implement OAuth2 authentication
+Status: Blocked
+Progress: Basic login flow implemented
+Blocker: Unsure about token management strategy
+Question: Should we use short-lived JWTs with refresh or longer expiration?
+Context: Currently storing tokens in localStorage
 ```
 
+**Cost-Optimized Multi-Agent Workflow:**
+
+```plaintext
+# Phase 1: Planning (o1 - $0.15/1k tokens)
+- Problem decomposition
+- Architecture design
+- Risk assessment
+
+# Phase 2: Implementation (Claude 3.7 - $0.03/1k tokens)
+- Code writing
+- Testing
+- Documentation
+
+# Phase 3: Targeted Planning (o3-mini - $0.015/1k tokens)
+- Specific implementation questions
+- Code optimization advice
+- Cost-effective reasoning
+```
+
+**Key Benefits of This Architecture:**
+- 💸 **90% Cost Reduction**: Use o1 only for critical planning decisions
+- 🤖 **Automatic Role Assignment**: No need to explicitly switch between roles
+- 🔄 **Contextual Prompting**: Messages automatically formatted for planning
+- ⚡ **Faster Development**: Models specialized for their most efficient tasks
+
+### Supported Models
+
 The server currently supports these models:
 
 - gpt-4o (default)
 - gpt-4o-mini
 - o1-preview
 - o1-mini
+- o1
+- o3-mini
+
+### Example Commands
+
+```plaintext
+# Basic planning request
+@o1 How should we structure the database for a multi-tenant SaaS app?
+
+# Planning with explicit task context
+@o1
+Task: Implement real-time notification system
+Status: Starting implementation
+Question: What's the best approach for handling WebSocket connections at scale?
+
+# Cost-efficient targeted planning
+@o3-mini
+Task: Optimize API response times
+Status: In progress
+Context: Current response time is 1.2s for listing endpoints
+Question: Which indexes should I add to improve query performance?
+
+# Using different models for specific strengths
+@gpt-4o Can you help me debug this React component?
+@o1 Design a scalable architecture for this microservice
+```
 
 ### Tools
 
@@ -72,6 +162,13 @@ The server currently supports these models:
      - `messages`: Array of messages (required)
      - `model`: Which model to use (optional, defaults to gpt-4o)
 
+2. `openai_plan`
+   - Specialized tool for complex reasoning tasks and inter-agent communication
+   - Arguments:
+     - `messages`: Array of messages with developer role support (required)
+     - `model`: Planning model to use (o1-preview, o1-mini, o1, o3-mini)
+     - `reasoning_effort`: Cognitive effort level (low/medium/high, defaults to low)
+
 ## Problems
 
 This is alpha software, so may have bugs. If you have an issue, check Claude Desktop's MCP logs:
@@ -104,12 +201,17 @@ pnpm dev
 ## Verified Platforms
 
 - [x] macOS
-- [ ] Linux
+- [x ] Linux
 
 ## License
 
 MIT
 
-## Author
+## Authors
+
+- [edwardtang](https://github.com/edwardtang) 🛠️ Current maintainer  
+  _Building upon the foundations of:_  
+  - [mzxrai](https://github.com/mzxrai) 🚀 Original MCP Server ([mcp-openai](https://github.com/mzxrai/mcp-openai))  
+  - [grapeot](https://github.com/grapeot) 🤖 Multi-agent Architecture ([devin.cursorrules](https://github.com/grapeot/devin.cursorrules/tree/multi-agent))  
 
-[mzxrai](https://github.com/mzxrai) 
+🙏 Grateful for the open source community's collective wisdom that made this project possible.

index.ts

@@ -66,6 +66,14 @@ const DEFAULT_DEVELOPER_CONTENT = [
     }
 ];
 
+// Define default planner content for the multi-agent system
+const DEFAULT_PLANNER_CONTENT = [
+    {
+        "text": "# Planner Agent\n\nYou are the Planner in a multi-agent collaboration system. Your role is to provide high-level guidance, analysis, and task breakdown. You analyze the Executor's work and provide strategic direction.\n\n## Your Responsibilities\n\n- Break down complex problems into manageable tasks\n- Define clear success criteria for the project\n- Analyze technical challenges and propose solutions\n- Review the Executor's progress and provide guidance\n- Make critical decisions about project direction\n- Use advanced reasoning models (o1, o1-preview) for deep analysis\n\n## When Responding to the Executor\n\nWhen the Executor reports progress or asks for guidance, analyze their request carefully and respond with clear instructions in the `Next Steps and Action Items` section. Use this format:\n\n```\n[PLANNER RESPONSE]\nAnalysis: {Your assessment of the current situation}\nDecision: {Your decision about how to proceed}\nNext Steps:\n1. {Clear, actionable instruction}\n2. {Another instruction}\n...\nConsiderations: {Important factors the Executor should keep in mind}\n```\n\nThink deeply about the problem. Prioritize agility but don't over-engineer. Foresee challenges and derisk earlier. If opportunity sizing or probing experiments can reduce risk with low cost, instruct the Executor to do them.",
+        "type": "text"
+    }
+];
+
 // Define available tools
 const TOOLS: Tool[] = [
     {
@@ -291,9 +299,32 @@ server.setRequestHandler(CallToolRequestSchema, async (request): Promise<{
                         if (msg.role === 'system') {
                             return { role: 'system', content: msg.content } as ChatCompletionSystemMessageParam;
                         } else if (msg.role === 'user') {
-                            return { role: 'user', content: msg.content } as ChatCompletionUserMessageParam;
+                            // When user sends a message to openai_plan, they're always acting as an executor
+                            // seeking guidance from the planner (o1)
+                            const executorRequestWrapper = `
+[EXECUTOR REQUEST]
+Task: ${msg.content.toLowerCase().includes('task:') ? msg.content : `Project planning/implementation`}
+Status: ${msg.content.toLowerCase().includes('status:') ? 
+    msg.content.substring(msg.content.toLowerCase().indexOf('status:') + 7).split('\n')[0].trim() : 
+    `Seeking guidance`}
+Question: ${msg.content.replace(/@o1/g, '').replace(/@planner/g, '').trim()}
+
+Please analyze this request and provide guidance on the next steps. Think like a founder. Prioritize agility and don't over-engineer. Think deeply. Try to foresee challenges and derisk earlier.
+`;
+                            return { 
+                                role: 'user', 
+                                content: executorRequestWrapper 
+                            } as ChatCompletionUserMessageParam;
                         } else if (msg.role === 'assistant') {
-                            return { role: 'assistant', content: msg.content } as ChatCompletionAssistantMessageParam;
+                            // When assistant responds in openai_plan, it's always as the planner
+                            const formattedContent = [
+                                ...DEFAULT_PLANNER_CONTENT,
+                                { type: "text", text: msg.content }
+                            ];
+                            return { 
+                                role: 'assistant', 
+                                content: formattedContent 
+                            } as ChatCompletionAssistantMessageParam;
                         }
                     } else if (Array.isArray(msg.content)) {
                         // Array of content parts
@@ -303,9 +334,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request): Promise<{
                         }));
 
                         if (msg.role === 'user') {
-                            return { role: 'user', content: contentParts } as ChatCompletionUserMessageParam;
+                            // All user messages to openai_plan are from executor to planner
+                            const firstPart = msg.content[0];
+                            const firstPartText = firstPart && 'text' in firstPart ? firstPart.text : '';
+                            
+                            const modifiedContent = [...contentParts];
+                            modifiedContent[0] = {
+                                type: 'text',
+                                text: `
+[EXECUTOR REQUEST]
+Task: ${firstPartText.toLowerCase().includes('task:') ? firstPartText : `Project planning/implementation`}
+Status: ${firstPartText.toLowerCase().includes('status:') ? 
+    firstPartText.substring(firstPartText.toLowerCase().indexOf('status:') + 7).split('\n')[0].trim() : 
+    `Seeking guidance`}
+Question: ${firstPartText.replace(/@o1/g, '').replace(/@planner/g, '').trim()}
+
+Please analyze this request and provide guidance on the next steps. Think like a founder. Prioritize agility and don't over-engineer. Think deeply. Try to foresee challenges and derisk earlier.
+`
+                            };
+                            return { role: 'user', content: modifiedContent } as ChatCompletionUserMessageParam;
                         } else if (msg.role === 'assistant') {
-                            return { role: 'assistant', content: contentParts } as ChatCompletionAssistantMessageParam;
+                            // All assistant responses in openai_plan are from planner to executor
+                            return { 
+                                role: 'assistant', 
+                                content: [...DEFAULT_PLANNER_CONTENT, ...contentParts] 
+                            } as ChatCompletionAssistantMessageParam;
                         }
                     }