otherapi_key

OpenAI

Toolkit for OpenAI APIs: manage Assistants, Threads/Messages; upload/list/delete Files; list/retrieve Models (including vision/multimodal); and view fine-tune listings and events.

Verdict

The OpenAI MCP lets your team manage Assistants, threads, and fine-tuning jobs directly from Switchy. @mention it to spin up a new Assistant with specific instructions, create conversation threads, upload training files, or check which models your org has access to. This is most useful for teams building custom AI workflows who need to prototype Assistants, manage fine-tune runs, or inspect file uploads without leaving the workspace. Trade-off: you're working with OpenAI's lower-level API primitives, not the ChatGPT interface — expect to handle thread IDs and assistant configurations yourself.

Common use cases

  • Prototype custom Assistants with specific instructions
  • Manage fine-tuning jobs for domain models
  • Inspect uploaded training files across projects
  • Create conversation threads for testing flows
  • Audit which models your org can access

Integration

Vendor
OpenAI
Category
other
Auth
API_KEY
Tools
14
Composio slug
openai

Tools

  • Create Assistant

    Tool to create a new assistant with specified parameters. use after finalizing model, tools, and instructions.

  • Create Message

    Tool to create a new message in a specific thread. use when adding messages to an existing conversation after confirming the thread id.

  • Create Thread

    Tool to create a new thread. use when initializing a conversation with optional starter messages.

  • Delete assistant
    destructive

    Tool to delete a specific assistant by its id. use when you need to remove an assistant after confirming its id.

  • Delete file
    destructive

    Tool to delete a file. use when you need to remove an uploaded file by its id after confirming the target.

  • List files

    Tool to retrieve a list of files. use when you need to view all files uploaded to your organization.

  • List fine-tunes

    Tool to list your organization's fine-tuning jobs. use when you need to review all fine-tune runs.

  • List models

    Tool to list available models. use when you need to discover which models you can call. use after confirming your api key is valid.

  • List run steps

    Tool to retrieve all steps of a specific run. use when you need to inspect each step's details after initiating a run.

  • Modify thread

    Tool to modify an existing thread's metadata. use after obtaining the thread id when you need to update metadata.

  • Retrieve assistant

    Tool to retrieve details of a specific assistant. use when you need to confirm assistant metadata before performing further operations.

  • Retrieve model

    Tool to retrieve details of a specific model. use when you have a model id and need to confirm its metadata before using it.

  • Retrieve thread

    Tool to retrieve details of a specific thread by its id. use when you need to fetch thread metadata before listing messages.

  • Upload file

    Tool to upload a file for use across openai endpoints. use before referencing the file in tasks like fine-tuning.

Setup

Setup guide

  1. 11. In Switchy, open your workspace settings and navigate to the Integrations tab. 2. Click 'Add MCP Integration' and select OpenAI from the list. 3. You'll be prompted to enter an OpenAI API key — generate one at platform.openai.com/api-keys with permissions for Assistants, Files, and Fine-tuning. 4. Paste the key into Switchy and click 'Connect'. 5. Switchy will verify the key by calling the List Models endpoint. 6. Once connected, open any Space and type '@OpenAI list models' to confirm the integration works. 7. You'll see a list of models your organization can access — if that appears, you're ready to create Assistants, threads, and manage files.

What teammates see: by default, memories from OpenAI are scoped to the Space (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.

Works well with

Top models

Compatibility data appears once enough Spaces have used this MCP together with a given model.

How Switchy teams use it

Not enough Spaces yet to publish anonymised usage stats (we require ≥ 50 Spaces per week).

Starter prompts

Create Support Assistant

@OpenAI create an assistant named 'Support Bot' using gpt-4 with instructions to answer customer questions politely and concisely
Open in a Space →

Start Conversation Thread

@OpenAI create a new thread with the starter message 'Hello, I need help with my account'
Open in a Space →

Example outputs

Illustrative - representative of the model's voice and quality, not literal recordings.

Prompt

@OpenAI list all fine-tuning jobs from the last 30 days and show me which ones completed successfully

Output

Found 4 fine-tuning jobs in the last 30 days. Two completed successfully: 'ft-abc123' (GPT-3.5-turbo fine-tune on customer support data, finished Jan 15) and 'ft-def456' (GPT-4 fine-tune on legal documents, finished Jan 22). One job 'ft-ghi789' failed due to insufficient training examples. One job 'ft-jkl012' is still running (82% complete). The successful models are now available in your account and can be called using their fine-tune IDs.

Notes

This example shows read-only monitoring of fine-tuning operations. Requires an API key with access to your organization's fine-tuning history. The MCP returns job metadata but cannot access the underlying training data or model weights. Useful for tracking training pipeline status without leaving your workspace.

Prompt

@OpenAI create a new assistant named 'Code Reviewer' that uses GPT-4 and has code interpreter enabled

Output

Created assistant 'Code Reviewer' with ID 'asst_xyz789'. Configuration: model set to gpt-4-turbo-preview, code interpreter tool enabled, no file search or function calling. The assistant is now active and can be used in threads. You'll need this assistant ID to create threads and send messages. Note that using this assistant will incur GPT-4 API costs per message, and code interpreter executions count toward your usage limits.

Notes

This example demonstrates creating a persistent assistant resource. The assistant remains in your OpenAI account until explicitly deleted, and each message sent to it incurs API costs. Be aware that assistants with code interpreter can execute Python code in a sandboxed environment—review security implications before using with untrusted input.

Prompt

@OpenAI check what models are available in my account, then recommend which one I should use for summarizing technical documentation

Output

Your account has access to 12 models including GPT-4-turbo, GPT-4, GPT-3.5-turbo, and several legacy versions. For summarizing technical documentation, I recommend GPT-4-turbo-preview: it has a 128k token context window (can process ~300 pages in one request), strong technical comprehension, and costs $0.01 per 1k input tokens. If cost is a priority, GPT-3.5-turbo-16k works well for shorter docs at $0.001 per 1k tokens but may miss nuanced technical details. Avoid the base GPT-4 model—it has only an 8k context window.

Notes

This example pairs the MCP's list-models capability with the AI's reasoning to provide contextualized recommendations. The model availability and pricing shown here are illustrative—your actual account access depends on your OpenAI organization tier and any custom rate limits. Always verify current pricing before committing to high-volume usage.

Use-case deep-dives

Multi-agent chatbot prototyping

When this MCP wins for rapid assistant iteration

A 3-person AI product team is building a customer-facing chatbot with multiple specialized assistants (billing, onboarding, technical support). They need to spin up new assistants, test conversation flows, and delete failed experiments daily. The OpenAI MCP is the right call here because it exposes the full Assistants API lifecycle—create, message, delete—without leaving Switchy. The team can iterate on instructions and tool configs in shared chats, then push changes via the MCP in under a minute. The threshold: if you're managing more than 10 assistants or need version control on assistant configs, you'll outgrow this MCP and want a proper CI/CD pipeline. For early-stage prototyping with a handful of assistants, this MCP cuts iteration time in half.

Fine-tune job monitoring

When this MCP barely justifies the setup cost

A solo ML engineer is running weekly fine-tuning jobs on GPT-3.5 for a niche legal document classifier. She wants to check job status and list completed runs without opening the OpenAI dashboard. The OpenAI MCP technically works for this—list fine-tunes and list models cover the read-only monitoring—but it's borderline overkill. The MCP requires an API key in Switchy's settings, and the payoff is just avoiding a browser tab. If she's already in Switchy for other integrations (Linear, GitHub), the marginal value is there. If this is the only OpenAI task she does in Switchy, she's better off bookmarking the dashboard. The buying threshold is whether you're doing at least two other OpenAI workflows in the same workspace.

Support team file cleanup

When this MCP handles the unglamorous file hygiene work

A 6-person support team uploads hundreds of customer transcripts and PDFs to OpenAI for retrieval-augmented generation in their internal knowledge assistant. Every month, they need to audit and delete outdated files to stay under quota. The OpenAI MCP is the right tool because it exposes list files and delete file in a shared workspace where the whole team can see what's being purged. One person runs the list, the team flags files for deletion in a Switchy thread, then someone executes the batch delete—all without juggling API keys or writing throwaway scripts. The trade-off: if your file count exceeds 500, the list tool gets slow and you'll want a dedicated admin script. For teams under that threshold doing quarterly or monthly cleanups, this MCP turns a 2-hour task into a 20-minute team exercise.

Frequently asked

What does the OpenAI MCP do in Switchy?

It connects your team's Switchy workspace to OpenAI's platform APIs — creating assistants, managing threads and messages, uploading files for fine-tuning, and listing available models. You're not just calling ChatGPT; you're orchestrating OpenAI's developer tools (Assistants API, fine-tuning jobs, file storage) from inside Switchy. Use it when your team needs to build, test, or manage custom AI workflows on OpenAI's infrastructure.

Do I need an OpenAI API key to connect this MCP?

Yes. You authenticate with an OpenAI API key, not OAuth. Whoever connects the MCP must generate a key from their OpenAI account (platform.openai.com/api-keys) and paste it into Switchy. That key's permissions and usage limits apply to every tool call the MCP makes. If your team shares one OpenAI organization, use a service account key so you're not tied to one person's login.

Can this MCP call GPT-4 or generate images with DALL·E?

No. This MCP wraps OpenAI's platform management APIs — creating assistants, threads, and fine-tune jobs — not the chat completions or image generation endpoints. If you want to call GPT-4 or DALL·E directly from Switchy, you'd use a different integration or build a custom tool that hits those endpoints. This one is for orchestrating OpenAI's developer infrastructure, not running inference.

How is this different from just using the OpenAI Playground?

The Playground is a single-user UI for testing prompts. This MCP lets your whole team create and manage assistants, threads, and files programmatically from Switchy — no context-switching to OpenAI's dashboard. You can script multi-step workflows (upload a file, start a fine-tune, check status) and share the results in Switchy channels. Use the Playground for quick experiments; use this MCP when you need repeatable, team-visible automation.

Who on my team should connect the OpenAI MCP?

Whoever owns your OpenAI organization's API keys and budget. The MCP's tool calls count against your OpenAI usage limits and bill to the account tied to the API key. If you have separate dev and prod OpenAI orgs, connect separate MCP instances in Switchy with the corresponding keys. Don't let junior team members connect their personal OpenAI keys — you'll lose visibility and cost control.

Data last verified 607 hours ago.Sources aggregated hourly to weekly. See docs/architecture/model-directory.md.