FOTOhub now works inside Claude, Cursor and VS Code

Summary

FOTOhub's catalogue of 226 AI models is now reachable from inside the tools where creators and developers already spend their day. The FOTOhub MCP server, live at apis.fotohub.app/mcp and listed in the official Model Context Protocol registry as app.fotohub/fotohub, exposes 28 tools for image, video, audio, chat and account management to any MCP-capable client: Claude Desktop, Cursor, Windsurf, VS Code and a growing list of agent frameworks. Setup is a nine-line JSON block and an API key. The same standard works in the other direction too: FOTOhub Chat Live accepts external MCP servers, so a team can plug its own tools into a FOTOhub conversation and have the model call them mid-task. Every call is billed exactly like a REST API call, from the same balance, at the same prices, with no MCP surcharge. This article explains what shipped, how it works, what it costs and where it is heading.

The copy-paste tax

Every creator who works with an AI assistant knows the loop. You describe a campaign to the assistant. It writes a strong brief, three headlines and a shot list. Then the work stops, because the assistant cannot render a single frame of it. You copy the shot list into an image generator, download the results, upload them to a video tool, download again, open an editor for captions, and paste the whole thing back into the chat to ask for the next revision.

Developers know a version of the same loop. An agent in Cursor can scaffold an entire landing page in a minute, then leave a folder of grey placeholder rectangles where the product photos should be, because it has no way to make them.

We call it the copy-paste tax. It is not measured in dollars, like the subscription stacking we wrote about last week. It is measured in context: every time work leaves the conversation, the assistant forgets what you were doing, and you become the integration layer between tools that were never designed to talk to each other.

The Model Context Protocol exists to remove that tax. FOTOhub now speaks it fluently, in both directions.

!One connection: FOTOhub plugs into any MCP client

What MCP is, in one paragraph

MCP, the Model Context Protocol, is an open standard for connecting AI assistants to external tools and data. An MCP server describes what it can do in a machine-readable way. An MCP client, such as Claude Desktop or Cursor, reads that description and lets the model call those tools during a conversation, with the user's permission. The protocol was introduced in late 2024 and has since become the common plug for agent tooling: one connection format that every serious client supports, so a tool built once works everywhere. Think of it as USB-C for AI assistants. FOTOhub is now one of the things you can plug in.

What FOTOhub ships today

Two pieces, built to work together.

A production MCP server. FOTOhub runs a remote MCP server at `https://apis.fotohub.app/mcp/`, speaking the current MCP specification (protocol version 2025-03-26) over Streamable HTTP, with Server-Sent Events as a fallback transport and a local stdio mode for developers who want to run it on their own machine. It has been in production since July 2026 and is listed in the official MCP registry under the name `app.fotohub/fotohub`, which means MCP clients that browse the registry can find and add it without anyone typing a URL.

An MCP client inside FOTOhub Chat Live. At `/dashboard/chat-live`, the Plus menu has an "MCP servers" entry. Add a server by URL with a token, or connect through OAuth, and the tools it exposes become available to the model in that conversation. Credentials are stored in encrypted vault storage, never in the browser. This is the same standard, pointed the other way: instead of FOTOhub living inside your agent, your tools live inside FOTOhub.

Between them, the two halves make FOTOhub one of the first creative platforms of its size that can be both a tool for agents and a host for them.

The 28 tools

The server exposes 28 tools, grouped by what they produce. Image and audio tools return results in one call. Video tools return a job id and a polling tool, because a 10-second render takes longer than a chat turn should wait.

Category	Tools	What they do
Image (8)	generate_image, edit_image, inpaint_image, style_transfer, upscale_image, remove_background, analyze_image, enhance_prompt	Generate from text with any supported image model (Seedream 5.0 by default), edit with a prompt or a mask, transfer a style, upscale 2x or 4x, cut out backgrounds, describe an image, and rewrite a weak prompt into a strong one
Video (7)	generate_video, image_to_video, extend_video, generate_story, generate_shorts, add_subtitles, get_job_status	Text and image to video across the video catalogue (Veo 3.1 by default), extend a clip, produce a multi-scene story with voiceover, cut long footage into vertical shorts, burn in subtitles, and check on any running job
Audio (6)	text_to_speech, generate_music, generate_sfx, transcribe_audio, voice_clone, separate_stems	Narration with the IDA Voice family and other voices, full music tracks, sound effects up to 30 seconds, transcription, plus voice cloning and stem separation, which today point the agent to the dashboard while their MCP routing is completed
Chat (3)	chat_completion, translate_text, gabriel_route	Call a second model from the first (Claude, GPT, Gemini, DeepSeek and Nova families), translate text, and ask Gabriel, FOTOhub's orchestrator, which model fits a task
Utility (4)	check_balance, list_models, list_generations, search_photos	Read your balance and monthly spend, list the live model catalogue, browse your recent generations, and search your library by meaning rather than by filename

Every tool carries a plain-language description and typed parameters, so the model knows, without being told, that generate_video wants a duration of 5 or 10 seconds and that upscale_image accepts a factor of 2 or 4. That is what lets a user say "make this poster sharper and cut a 16:9 version" and have the agent chain upscale_image and edit_image on its own.

Two minutes to connect

Connecting takes an API key and one JSON block. Keys are created in the developer console at fotohub.app/console, under Keys. Live keys start with `fh_live_`, test keys with `fh_test_`.

Claude Desktop, Cursor and Windsurf all read the same shape:

```json

{

"mcpServers": {

"fotohub": {

"url": "https://apis.fotohub.app/mcp/",

"headers": {

"Authorization": "Bearer fh_live_your_api_key"

}

}

}

}

```

VS Code uses a `.vscode/mcp.json` file with an explicit transport type:

```json

{

"servers": {

"fotohub": {

"type": "http",

"url": "https://apis.fotohub.app/mcp/",

"headers": {

"Authorization": "Bearer fh_live_YOUR_API_KEY"

}

}

}

}

```

Restart the client and the 28 tools appear in its tool list. From there the assistant decides when to use them, and most clients ask you to approve a tool the first time it runs.

Clients that implement MCP authorization can skip the key entirely. The server publishes standard discovery metadata at `/.well-known/oauth-protected-resource` and `/.well-known/oauth-authorization-server`, supports dynamic client registration, and issues short-lived access tokens over OAuth 2.1 with PKCE. In practice: click Connect in a client that supports it, log in to FOTOhub in the popup, and you are done.

Full setup guides, per client, live at docs.fotohub.app/api/mcp and docs.fotohub.app/guides/mcp-integration.

Three scenes the protocol makes routine

A producer in Claude Desktop. She pastes a client brief for a skincare launch and asks for a campaign concept. Claude writes it, then, because FOTOhub is connected, offers to render the hero shot. She says yes. Claude calls generate_image with the brief's palette and a 3:2 ratio, shows the result, and she asks for the bottle to be moved to the left third. Claude calls edit_image with a mask. She asks for a version for Stories; Claude calls edit_image again for 9:16, then upscale_image at 2x for print. Four assets, one conversation, nothing downloaded until the end. The whole exchange lands in her FOTOhub library, where list_generations can find it next week.

A developer in Cursor. He is building an e-commerce demo and needs twelve product photos that do not exist yet. He tells the agent what the products are; the agent calls generate_image twelve times with consistent lighting instructions, writes the URLs into the seed data, and moves on to the checkout flow. Total detour from writing code: none.

A marketer producing short-form video. She asks the assistant for a 10-second product clip from a still. The assistant calls image_to_video, gets a job id, and keeps talking with her about captions while the render runs. It polls get_job_status, reports the finished clip, then calls add_subtitles with the caption text they agreed on and generate_shorts to cut it for TikTok and Reels. She reviews the results in FOTOhub and posts.

None of this required a new interface. The interface was the chat she already had open.

Video, stories and shorts run as jobs

Video tools follow one pattern. The call returns immediately with a job id and a poll URL; get_job_status returns progress, then the finished file. This is the same job model that powers FOTOhub's own web studios and the public REST API, so an agent that starts a render in Cursor can hand the job id to a colleague who checks it in a script, or to the dashboard, where it appears in the same history.

generate_story is the heaviest tool in the set: a multi-scene film with voiceover, 15 to 60 seconds long, typically two to five minutes to render. generate_shorts takes a long recording and returns the vertical cuts. add_subtitles burns captions into an existing clip. All three are asynchronous and all three are polled with the same get_job_status.

Billing: same price list, no MCP surcharge

The MCP server does not have its own price list. Every tool forwards to the same API routes that answer `POST /v1/ai/generate/image` from the SDKs, using your own key, so the charge is calculated in one place and appears in one history. An image generated from Claude Desktop costs exactly what it costs from Python. There is no per-seat fee for MCP, no connector fee and no minimum.

Agents can be cost-aware. check_balance returns your current balance, pending charges and spend this month, and a client such as Claude will happily call it before a large batch if you ask it to. Rate limits are per key: 60 requests a minute by default, adjustable per key up to 600, with a standard 429 response and a Retry-After header when a limit is hit.

Because the key is yours, the spending controls are yours too. A key for a junior designer's assistant can be capped at a low rate limit and revoked in one click if the laptop goes missing.

MCP, REST or SDK: which one to use

All three reach the same catalogue and the same balance. They differ in who is doing the calling.

	MCP	REST API	Python and TypeScript SDKs
Who calls	An AI assistant or agent, on the user's behalf	Your backend, directly	Your code, with typed helpers
Best for	Creative work inside Claude, Cursor, VS Code; conversational pipelines	Production integrations, webhooks, batch jobs	Application code, scripts, quick prototypes
Setup	One JSON block or an OAuth login	HTTP client and a key	`pip install fotohub` or `npm install fotohub`
Decides which tool	The model, from tool descriptions	You	You
Price	Identical	Identical	Identical

Most teams end up using two of the three: MCP for the people who think in conversations, REST or SDKs for the systems that run without anyone watching. Because the key and the history are shared, the assets flow between them without a handoff.

Security and control

Everything the server accepts is scoped and revocable.

• API keys are created and revoked in the console; a revoked key stops working on the next call.
• OAuth 2.1 with mandatory PKCE (S256 only). Access tokens live for one hour; refresh tokens for 90 days and rotate on every use, so a leaked refresh token dies the moment the legitimate client refreshes.
• Scopes split the surface into mcp:image, mcp:video, mcp:audio, mcp:chat, mcp:billing, mcp:read and mcp:write, so a client can be granted image generation without access to your balance.
• Unauthenticated requests get a standards-compliant 401 with a WWW-Authenticate header pointing at the discovery metadata, which is what lets compatible clients start the login flow on their own.

On the client side, in Chat Live, any server URL a user adds is checked before the first request: private and loopback ranges, link-local addresses, cloud metadata hosts and DNS names that resolve to them are refused. Discovered OAuth endpoints go through the same check. Credentials are stored in an encrypted vault and referenced by id; the chat service reads them only at call time.

The other direction: bring your own tools into FOTOhub chat

Most of this article is about FOTOhub inside your agent. The client half deserves its own scene, because it is the part that turns Chat Live into a workspace rather than a chatbot.

A three-person studio keeps its project tracker, its asset naming rules and its client list behind an internal MCP server, the kind a developer can write in an afternoon with any MCP SDK. They add it in Chat Live with a token. Now a conversation can go: "Start the deliverables for the Nordic Bakery job." The model calls the studio's tool to read the brief and the naming convention, generates the six product shots on the FOTOhub side, and calls the tracker tool again to file them under the right project. Up to five rounds of tool calls can happen inside one reply, which is enough for read, generate, check and write.

Connections can be made with a URL and a bearer token, or through OAuth 2.1 with PKCE when the external server supports it; the panel opens a popup, you log in on the other side, and the tools appear as chips in the composer. Tool calling in Chat Live currently runs on the Claude model family, which is where tool use is strongest today.

!Chat Live becomes a workspace with your own tools connected

Why a creative platform cares about a protocol

Last week we wrote that the single-model subscription is a 2024 idea. The single-app interface is heading the same way. More and more creative work starts as a conversation with an assistant, and the assistant, not the human, is increasingly the one deciding which tool to call.

That changes what a platform has to be. It is not enough to have a good web app. The catalogue has to be callable, described in a way a model understands, priced in a way an agent can reason about, and secured in a way an IT department will approve. MCP is how the industry has agreed to do all four, and FOTOhub built for it early: the server shipped in July, the registry listing followed within days, and the client side followed in Chat Live.

The bet is the same one behind the single subscription. Whichever assistant wins a creator's attention, Claude, a coding agent, or one that does not exist yet, it will need somewhere to render. FOTOhub intends to be that place, with 226 models behind one key, at one price list, from anywhere the protocol reaches.

What is not in MCP yet

Three honest gaps. Voice cloning and stem separation appear in the tool list but hand the agent back to the dashboard while their MCP routing is completed. Model training tools exist in the codebase and stay unlisted until the training service is in production. Flows automations, 3D generation and the photo editor's layer tools are not exposed through MCP yet; they remain web-first for now. All of these are on the roadmap for the autumn releases.

Frequently asked questions

Which clients work? Any MCP client that supports remote servers over Streamable HTTP: Claude Desktop, Cursor, Windsurf, VS Code with MCP support, and most agent frameworks that implement the protocol. A local stdio mode is available for tooling that prefers a subprocess.

What do I need to start? A FOTOhub account, an API key from the developer console at fotohub.app/console, and a funded developer balance for generation. There is no separate MCP plan or fee.

Can I limit what an agent may do? Yes. Rate limits are set per key, and OAuth scopes restrict clients to specific categories such as image only. Most clients also ask for approval before a tool runs.

Is video available? Yes, asynchronously. Video tools return a job id; the agent polls get_job_status until the file is ready. Renders appear in your FOTOhub history alongside web generations.

Where is the server listed? In the official MCP registry as app.fotohub/fotohub. Documentation, including every tool's parameters, is at docs.fotohub.app/api/mcp.

Can my company connect its own tools to FOTOhub? Yes. In Chat Live, open the Plus menu and choose MCP servers. Add any MCP server over HTTP with a token or through OAuth.

Does MCP cost more than the API? No. The same operation costs the same whether it is called from Claude Desktop, from curl or from the Python SDK.

A note from the founder

FOTOhub was founded in September 2025 by Mateusz Ulewicz, Founder and CTO, who designed the orchestration layer, the GPU fleet, the billing system and the IDA model family that the platform runs on. Before FOTOhub he spent two decades in engineering, including work at Amazon Web Services and Nokia. The company has raised $8.6 million to date, counts Amazon Web Services and DGE3 Investment among its backers, was valued at $180 million in Q2 2026, and serves over 1 million users in 46 countries.

"We spent a year making 226 models feel like one product for a person sitting at a screen," Ulewicz says. "The next step was obvious: make them feel like one product for an agent. MCP gave us a standard to do that without asking anyone to learn our interface. You keep your assistant, your editor, your habits. We bring the rendering."

On why a creative platform should be a host for other people's tools, not only a guest in theirs: "A studio's real workflow is never just generation. It is the brief, the tracker, the naming rules, the client's asset library. If our chat cannot reach those, it is a toy. So we built the client side with the same care as the server side. A conversation in FOTOhub can now read from your systems, generate with ours, and write the result back where your team will look for it. That is what a workspace is supposed to do."

Connect your first client with the guide at docs.fotohub.app/api/mcp, create a key at fotohub.app/console, or try Chat Live with your own MCP server at fotohub.app/dashboard/chat-live.