shimi-ask
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@shimi-askAnswer this question using my saved instructions: What should I do if a customer asks for a refund?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
shimi-ask — MCP Ask Server
שרת MCP מקומי (Streamable HTTP) שמאפשר ל־ChatGPT לענות על שאלות לפי הוראות שהמפעיל (שימי) מגדיר.
A local MCP server so ChatGPT (Developer Mode) can answer questions according to operator-controlled instructions. No OpenAI API key required on the server.
התקנה והרצה / Install & run
cd /workspace/chatgpt-mcp-ask
npm install
npm run build
npm startפיתוח עם reload:
npm run devMCP URL (מקומי):
http://localhost:3000/mcpHealth:
http://localhost:3000/healthפורט:
3000(או משתנה סביבהPORT)Host: ברירת מחדל
127.0.0.1(HOST=0.0.0.0ל־Docker / גישה חיצונית)
משתני סביבה אופציונליים:
משתנה | ברירת מחדל | תיאור |
|
| פורט האזנה |
|
| כתובת bind |
| (אוטומטי ל־localhost) | רשימה מופרדת בפסיקים ל־Host header (למשל דומיין של tunnel) |
Related MCP server: Agentic MCP
כלים / Tools
ask_question— עונה לשאלה לפי ההוראות השמורות בלבד (ללא LLM חיצוני בשרת).set_instructions— מחליף את מלוא טקסט ההוראות ושומר ל־data/instructions.txt.get_instructions— קורא את ההוראות הנוכחיות.
חיבור ל־ChatGPT (Developer Mode)
Settings → Security and login → הפעל Developer mode.
לך ל־Plugins → + → הוסף אפליקציית developer-mode.
כתובת ה־MCP חייבת להיות HTTPS ציבורי שמסתיים ב־
/mcp, או השתמש ב־Secure MCP Tunnel לשרת מקומי.
מקומי עם Tunnel
השרת אצלך רץ על http://localhost:3000/mcp. ChatGPT לא יכול לגשת ל־localhost ישירות — צריך:
Secure MCP Tunnel (אם זמין בחשבון), או
Tunnel חיצוני (למשל Cloudflare Tunnel / ngrok) שמפרסם HTTPS ל־
/mcp.
אם ה־Host של ה־tunnel אינו localhost, הגדר למשל:
HOST=0.0.0.0 ALLOWED_HOSTS=your-tunnel.example.com,localhost,127.0.0.1 npm startאחרי החיבור
קרא ל־
set_instructionsעם ההנחיות שלך (או ערוך אתdata/instructions.txtוהפעל מחדש).שאל שאלות — ChatGPT אמור להשתמש ב־
ask_question.
קבצים חשובים
src/index.ts— Express + Streamable HTTP על/mcpsrc/server.ts— רישום הכלים +instructionsל־MCPsrc/answer.ts— מענה דטרמיניסטי לפי ההוראותsrc/instructionsStore.ts— טעינה/שמירה ל־data/instructions.txtdata/instructions.txt— הוראות המפעיל
Docker (אופציונלי)
docker build -t shimi-ask .
docker run --rm -p 3000:3000 -v "$(pwd)/data:/app/data" -e HOST=0.0.0.0 shimi-askהערות
אין OAuth / אימות ב־v1.
אין צורך במפתח OpenAI בשרת — התשובות נגזרות מהוראות המפעיל בלבד.
פרויקט מקומי בלבד (ללא git / GitHub / Origin אלא אם תוסיף בעצמך).
Available Tools
3 toolsask_questionAsk questionARead-only
Use when the user asks something that should be answered per the operator’s current instructions. Do not invent facts outside those instructions; if empty/insufficient, say so.
| Name | Required | Description | Default |
|---|---|---|---|
| question | Yes | The user question to answer per operator instructions |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true, openWorldHint=false, and destructiveHint=false. The description adds behavioral context: it doesn't invent facts outside the instructions and explicitly says to state when instructions are empty/insufficient. This goes beyond the annotations and helps the agent calibrate expectations. It doesn't discuss rate limits or other behavior, but given the read-only nature and simple purpose, the description covers the critical aspects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the primary instruction front-loaded and the constraint/instruction-following behavior right after. Every sentence earns its place; no filler words or redundant phrases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read-only tool with 100% schema coverage and no output schema, the description is largely complete. It covers when to use, constraints, and edge behavior. It could arguably mention what a 'good answer' looks like or how to handle partial instructions, but given the simplicity and annotations, the missing piece is minimal.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%: the property 'question' has a description in the schema ('The user question to answer per operator instructions'). The tool description essentially restates this, so it doesn't add much semantics beyond the schema. A baseline of 3 is appropriate because the schema already documents the parameter fully.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('answer') and the resource ('the operator's current instructions'), which differentiates it from the sibling tools: get_instructions and set_instructions manage the instructions, while ask_question uses them to answer. It also conveys the tool's scope and constraints. However, it doesn't explicitly name the sibling tools or contrast with them directly, so it stops just short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It says 'Use when the user asks something that should be answered per the operator's current instructions.' This provides clear conditions for when to use the tool. It also includes guidance on what to do when instructions are empty or insufficient, which helps in edge cases. It doesn't explicitly exclude using it for non-question situations or name alternatives, but the context makes the decision fairly clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_instructionsGet instructionsARead-only
Read current operator instructions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already declares the tool is read-only, and the description's 'Read' aligns with that. The word 'current' adds a small contextual detail about the nature of the data (not historical), but otherwise the description does not disclose behavioral traits beyond the annotation. It is consistent and provides a minor extra nuance.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no wasted words. The verb 'Read' is front-loaded, and the resource is immediately clear. It is appropriately sized for such a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters, a read-only annotation, and no output schema, the description is sufficient to understand its function. It does not specify the return format, but that is not explicitly required and can be inferred from 'Read'. The tool is simple enough that the description covers the essentials.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description adds no parameter details, but none are needed since the schema is empty. The description does not hinder understanding of parameters, so the baseline score holds.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb (read) and resource (current operator instructions), making the tool's purpose obvious. It does not explicitly name sibling tools, but the verb 'read' implicitly contrasts with the sibling 'set_instructions', so it distinguishes without saying so.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus the alternatives. It does not mention conditions, exclusions, or why an agent might prefer it over ask_question or set_instructions. The description is purely declarative with no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
set_instructionsSet instructionsA
Use when the operator wants to command how future questions are answered. Replaces full instruction text.
| Name | Required | Description | Default |
|---|---|---|---|
| instructions | Yes | Full replacement operator instruction text |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that this is a full replacement, not an append or merge, and scopes the effect to future questions. Annotations already signal a non-read operation, so the description adds useful behavioral context beyond the structured hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with no filler. The usage trigger is front-loaded, and every word contributes to understanding the tool's purpose and behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter setter with annotations and full schema coverage, the description is complete. It explains the purpose, the replacement semantics, the future-facing scope, and the required input. No output schema is needed for this kind of write operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the single parameter is described as 'Full replacement operator instruction text.' The description's 'Replaces full instruction text' largely restates the schema rather than adding new parameter-level meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action — replacing the full instruction text that controls future answers — and clearly distinguishes it from reading instructions (get_instructions) or asking a question (ask_question). It goes beyond the name by explaining the operator's intent it serves.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Use when the operator wants to command how future questions are answered' gives a clear, direct trigger for invoking this tool. It does not explicitly mention alternatives or when not to use it, but the context and siblings make the intended use obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v1.0.0- First observed
ask_question - First observed
get_instructions - First observed
set_instructions
TDQS
Scored across 3 tools
Each tool has a clearly distinct role: reading instructions, asking a question constrained by those instructions, and setting instructions. No overlap in purpose.
All tools follow the same verb_noun snake_case pattern: get_instructions, ask_question, set_instructions. Perfectly consistent.
Three tools is a well-scoped set for a focused instruction-based Q&A server. Each tool earns its place.
The server covers the full lifecycle: read instructions, set instructions, and use them to answer questions. No obvious missing operations for its stated purpose.
Maintenance
Related MCP Connectors
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Remote MCP server exposing SMI Aware tools, resources, and skills over Streamable HTTP.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceLocal MCP server enabling Codex and ChatGPT to read/write files, execute commands, manage processes, use Git, and inspect images on the user's machine with full privileges.Apache 2.0
- AlicenseNot gradedqualityAmaintenanceEnables ChatGPT Web Developer Mode to interact with local repositories through MCP, providing tools for file editing, shell execution, Git worktrees, semantic navigation, and checkpoints.286 npm2MIT
- AlicenseNot gradedqualityBmaintenanceEnables ChatGPT Developer Mode to securely invoke multiple Windows-local stdio MCP servers through a single gateway, with tool namespacing, path restrictions, and serial execution control. It includes safe-file, image, and download tools for local workspace interaction.1MIT
- AlicenseNot gradedqualityBmaintenanceA secure MCP server that gives ChatGPT access to local terminal, files, and background processes, and lets it discover, manage, and call any registered MCP server on the machine.1MIT