What can an MCP server do?
Start from the action, not the vendor. Each page lists every verified MCP server that can do one thing, and names the exact tool it uses to do it.
MCP servers that can add a comment
Commenting is how an agent talks to people inside the tools they already use: a note on an issue, a reply on a pull request, a remark on a database row or a doc. Most collaboration servers expose it on whatever object they manage.
MCP servers that can add to a vector database
Querying a vector store only works if something put the vectors there first. Adding to a vector database is the write side: embed a chunk of text or an object and index it, so a later semantic search can find it. It is the indexing step behind every retrieval-augmented setup.
MCP servers that can cancel a subscription
Cancelling a subscription stops the recurring charge, which makes it a write with real money and real customer trust attached. When an agent handles a downgrade, a churn request, or a billing fix, a cancel tool ends the subscription on the platform that bills it.
MCP servers that can create a branch
Branch is one word for two related moves: a git branch for an isolated line of code, and a database branch for an isolated copy of your data. Both let an agent work on a change without touching the main line, and several servers expose the create as a single call.
MCP servers that can create a channel
Sometimes the right place to talk does not exist yet. An incident kicks off, a new project spins up, a topic outgrows the channel it was crowding, and the agent's first move is to make a home for it before anyone posts. Creating a channel is that step: a write that adds a new room to the workspace.
MCP servers that can create a customer
Before you can bill anyone, the billing system has to know who they are. Creating the customer record is the first write in almost every payments flow, and the major processors expose it as a one-call tool an agent can drive.
MCP servers that can create a document or page
When an agent produces something a person will read (a spec, a runbook, meeting notes, a wiki entry) it needs somewhere to put it. The document and wiki MCP servers expose page creation as a single tool, so the agent can write straight into the place your team already looks.
MCP servers that can create a payment
Money is the highest-stakes write an agent can make, and the payment MCP servers expose it plainly: create a payment link, raise an invoice, open a charge. The action is short. The care around it is not.
MCP servers that can create a project
A project is the container the rest of the work hangs off, and on these servers it means anything from a billable Postgres instance to a Sentry error stream to an Asana planning space. Setting one up is step one when an agent builds something end to end.
MCP servers that can create a task
Not every to-do belongs in a bug tracker. A task in a project tool or a personal list is its own thing, and when an agent breaks work into steps or files a follow-up, a create-task tool puts it where a person will actually see it.
MCP servers that can create a webhook
Webhooks are how a service tells you something happened instead of you polling for it. Creating one registers an endpoint a platform will call on an event, a new scan, a delivered email, a CRM change, so an agent can wire up a notification rather than check on a loop.
MCP servers that can create an incident
When something breaks, the incident is the record everything coordinates around: who is paged, what is happening, what was done. Creating one opens that record, so an agent that detects a problem can declare it rather than leave it as a quiet alert nobody owns.
MCP servers that can create an issue
An agent that finds a bug mid-task needs to file it where a human will see it, not bury it in a chat log. Every major tracker with an MCP server exposes one tool for that, under a different name each time.
MCP servers that can delete a file
Cleanup is part of the job: a stale config, a temp artifact, an obsolete doc that should not linger. A delete-file tool removes it at a path, on a code host or a storage service, so an agent can tidy up after itself rather than leave debris.
MCP servers that can generate an image
When an agent needs a picture rather than words, a text-to-image tool turns a prompt into a rendered image it can save or pass on. Several model-hosting servers expose this, and they differ mostly in which models sit behind the call and what the output is for.
MCP servers that can get a pull request
Listing PRs tells an agent what is open; getting one tells it what the change actually is. Fetching a single pull request pulls back the diff, the reviews, and the comment threads, the full record an agent needs to read a change rather than just count it.
MCP servers that can get issue details
Working an issue means reading it first: the full description, the comments, the labels, the current state. Getting one issue pulls all of that, so an agent can answer a question about it or act on it from the real record rather than a one-line title.
MCP servers that can get a page's content
When the answer lives in a doc, an agent has to fetch the page to read it. Getting a page returns its content, the spec, the runbook, the wiki article, so the model works from what the page actually says rather than its title.
MCP servers that can get a diff
To review a change, an agent has to see what actually changed. Getting a diff returns the lines added and removed, for a commit, a comparison, or a pull request, so the model reviews the real change rather than a summary of it.
MCP servers that can get the current user
An agent often needs to know who it is acting as: which account, what permissions, whose data it can see. Getting the current user returns the authenticated identity behind the connection, so the agent can confirm its scope before it acts or attribute work to the right account. It is a small call with broad use.
MCP servers that can list database tables
Before an agent can write a useful query it needs to know what is there: which tables exist, what the columns are called, how they relate. That discovery step is its own tool on most database MCP servers, separate from running the query itself.
MCP servers that can list available models
An agent that calls another model first needs to know which models it can call. A list-models tool returns the catalog a provider offers, so the agent picks the right one for the job instead of hard-coding a name that may have changed. Catalogs move; names go stale.
MCP servers that can list branches
Branches are the working surface of a repository, and an agent has to see which ones exist before it checks one out, merges into another, or prunes the dead ones. Listing branches answers that: every named line of work, including the ones nobody has touched in months.
MCP servers that can list chat channels
Before an agent can post to the right place, it has to know what places exist. Listing channels is how it discovers where conversations happen, the step before sending a message or reading recent history.
MCP servers that can list commits
When an agent needs to understand what changed and when, it reads the commit log. Listing commits is how it sees the history of a branch: who touched what, in what order, leading up to now.
MCP servers that can list dashboards
Observability lives in dashboards, and an agent that needs to read one first has to find it. Listing dashboards returns what exists so the agent can pick the right view, the latency board, the error panel, before it reads or links to it.
MCP servers that can list files
Before an agent reads or writes a specific file, it often has to find it: see what is in a folder, a vault, or a share. A list-files tool returns the contents of a directory so the agent can navigate to the file it actually needs.
MCP servers that can list incidents
When something is on fire, the first question an agent asks is the same one a responder asks: what's open right now? These servers answer it with a single read, returning the current incidents so the agent can summarize on-call status, triage what's active, or draft a report for the channel.
MCP servers that can list issues
Triage starts with seeing the list. Before an agent works a backlog, finds duplicates, or reports on what is open, it needs to list the issues and read their state, filtered down to the ones that matter.
MCP servers that can list organizations
On the platforms an agent works against, an organization is the top of the hierarchy: the account that owns the projects, the databases, the billing. Listing organizations returns the ones the connection can reach, so an agent knows which accounts are in scope before it drills into a project.
MCP servers that can list products
Billing logic usually starts from the catalog: which products exist, at what prices, before an agent builds an invoice or a payment link around one. A list-products tool returns that catalog so the agent works from real ids rather than guessed names.
MCP servers that can list projects
A project is the container the rest of the work sits in, so before an agent operates on one it usually lists them: which databases exist, which planning spaces, which it is allowed to touch. Listing projects returns that set so the agent picks the right id to act on.
MCP servers that can list pull requests
Reviewing what is open is its own job, separate from opening a PR. Before an agent picks up review work, triages a queue, or reports on what is in flight, it needs to list the pull requests and read their state.
MCP servers that can list repositories
Before an agent clones, audits, or reports across a codebase, it has to know which repositories exist. Listing repositories is the discovery step: enumerate what a workspace or account holds, then decide where to look first.
MCP servers that can list subscriptions
Recurring revenue lives in subscriptions, and an agent that reports on it, finds a churn risk, or acts on one first has to see the list. Listing subscriptions returns what is active, past due, or cancelled, so the agent works from the real billing state.
MCP servers that can list tasks
Before an agent reports progress or decides what to pick up, it has to read the list. Listing tasks is the triage read for project work: pull what is open, see who owns what, find the items that stalled.
MCP servers that can list users
Most agent actions in a workspace need a person's id, not their name. Listing users is how an agent resolves a handle to that id before it assigns work, mentions someone, or reports on who belongs.
MCP servers that can look up a stock price
Ask an agent what a stock is trading at and it cannot answer from training data: the number moved since the cutoff. A market-data server gives it a tool to pull the current price, or the history, the moment it needs them.
MCP servers that can merge a pull request
Opening a PR is the start; merging it is the commit. When an agent has approval and green checks, a merge tool lands the change into the base branch, the step that turns a proposal into shipped code.
MCP servers that can navigate a browser
Driving a browser starts with going somewhere: open a URL, load the page, work from what renders. A navigate tool is the first call in almost every browser-automation flow, the move that puts the agent on the page it needs to act on.
MCP servers that can open a pull request
A coding agent that writes a change should be able to propose it the way a person does: push a branch, open a pull request, and let CI and a reviewer take it from there. The servers for the major code hosts expose that as a single call.
MCP servers that can query a vector database
Semantic search runs on a vector database: text is embedded into vectors, and a query returns the nearest matches by meaning rather than exact words. When an agent needs that kind of retrieval, the vector-store servers expose a query tool over your collection.
MCP servers that can query metrics and logs
When an agent is debugging a production problem, it needs the same thing an on-call engineer reaches for: the metric that spiked, the log line around the error, the time window where things changed. Several observability MCP servers expose exactly that, so a model can pull telemetry instead of asking you to paste it.
MCP servers that can read a file
Plenty of agent work starts with reading a file it did not write: a config in a repo, a note in a vault, a document on a server. A read-file tool fetches the contents by path so the model can reason over what is actually there, not a guess about it.
MCP servers that can read channel history
Reading a channel is the opposite move from posting to one. An agent pulls the recent messages so it can summarize a thread, catch up on what happened while it was idle, or answer a question like "what did we decide here" from the actual record rather than a guess.
MCP servers that can refund a payment
A refund is the reverse of a charge, and just as consequential: money leaves your account and lands back with the customer. So it is a write you treat with care. When an agent handles a return or fixes a billing mistake, a refund tool issues it against the original payment.
MCP servers that can run a shell command
Some jobs do not map to a tidy API call. The agent just needs a shell: run a script, manipulate a file, exec into something and look around. A few infrastructure servers expose that, and the important difference between them is where the command actually runs.
MCP servers that can run SQL queries
Most database MCP servers come down to one tool: hand it SQL, get rows back. What changes is where the query runs (a hosted Postgres branch, a local SQLite file, an analytics column store) and how much guardrail sits in front of it before a statement reaches your data.
MCP servers that can scrape a web page
Search finds the page; scraping reads it. When an agent needs the actual content of a known URL, the docs page or the pricing table or the article behind a link, a scraping tool fetches it and returns clean text instead of raw HTML full of nav and ads.
MCP servers that can search documentation
When an agent hits an API it does not fully know, the fastest fix is to let it read the docs. A growing number of product MCP servers ship a documentation-search tool, so the model can look up the current, correct way to do something instead of guessing from stale training data.
MCP servers that can search the web
Training data has a cutoff; the web does not. When an agent needs something current (a release date, a price, a fact that changed last week) a web-search tool is how it finds out instead of guessing. A whole category of MCP servers exists to do exactly this, and they are not all the same.
MCP servers that can send a Slack message
Slack's write tools ship off by default, so "post this to the channel" is one capability you switch on deliberately. The Slack server handles it; the other team-chat platforms do the same under different tool names.
MCP servers that can send an email
An email send is one tool call: a recipient, a subject, a body, and the call almost always returns success. Whether the mail reaches an inbox, and whether it should have gone at all, is decided somewhere else.
MCP servers that can take a screenshot
A screenshot is how an agent shows its work on the visual web: proof a page rendered, a frame from a failing test, a design captured for comparison. Several browser and scraping servers expose it as one tool, and they split into two camps depending on whether you bring your own browser.
MCP servers that can trigger a CI build
A coding agent that just landed a fix often needs the next step too: start the build that proves it. The CI servers expose that as one call, so the agent can kick a job after a merge, rerun a flaky pipeline on demand, or fire the run that gates a deploy.
MCP servers that can update an issue
Most of an issue's life happens after it is filed. The status moves, the assignee changes, a label gets added, someone rewrites a vague body once they understand the bug. Updating an issue is that edit path: change the fields on a ticket that already exists.
MCP servers that can upload a file
"Upload a file" sounds like one action, but it covers at least three: filling a file input on a web page, putting an object in storage, and attaching media to a wiki or a chat. The verified servers below do different versions of it, and the right one depends on where the bytes are going.
MCP servers that can write a file
Reading a file is half of it; writing one is the other half. When an agent produces a config, a script, or a document and needs it to persist, a write-file tool creates or updates the file at a path, on a code host or a storage service.