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 a reaction
A reaction is the lightest way to respond: an emoji on a message that signals acknowledgement, agreement, or done without adding to the thread. When an agent confirms it saw something or marks a task picked up, a reaction tool adds that emoji to a message.
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 crawl a website
Scraping one page is a single fetch. Crawling is the harder job: start at a URL, follow links across a whole site, and bring back every page as clean text the model can read. It is how an agent turns a documentation site or a catalog into something it can reason over.
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 vector collection
A vector store organizes embeddings into collections, and before an agent can add or query vectors, the collection has to exist. Creating one sets up that container, with its dimensions and index, so the documents an agent indexes have somewhere to land.
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 dashboard
When an agent has set up monitoring or wired up data, the dashboard is how a human sees it. Creating one assembles the panels into a view, so the metrics, the funnels, the charts live somewhere a person can open rather than buried in a query.
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 folder
Organizing files means somewhere to put them, and that starts with a folder. Creating one makes a container, in cloud storage or a workspace, so an agent can file uploads, group designs, or set up a structure rather than dump everything at the root.
MCP servers that can create a label
Labels are how teams categorize work: a color and a name that mark an issue, a card, or a work item so it can be filtered and found. Creating one makes a new category, so an agent setting up a board or a triage scheme can define the tags before applying them.
MCP servers that can create a database
Most databases are created through SQL, but a couple of MCP servers expose it as a tool: hand it a name, get a new database. When an agent provisions a fresh database for a service or an isolated workspace, that one call sets it up.
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 share a file
Getting a file to someone usually means a link, not an attachment. Sharing a file creates a URL anyone with it can open, so an agent can hand off a document, an export, or an asset without emailing the bytes around.
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 invoice
An invoice is a bill with a paper trail: a customer, line items, an amount due, and a record both sides can point to later. For an agent, raising one is a single call, but the numbers on it have to come from somewhere real.
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 manage calendar events
A calendar is where intent becomes a commitment with a time on it. For an agent, managing one means reading what is already scheduled, adding new events, and moving or canceling them when plans change, without a human opening the calendar app.
MCP servers that can delete a branch
Branches pile up: a merged feature, a throwaway database copy, an experiment that went nowhere. Deleting one removes it, a git branch or a database branch, so an agent can clean up after itself instead of leaving stale branches behind.
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 delete a task
Tasks outlive their usefulness: a duplicate, a cancelled piece of work, a test item that should not clutter the board. Deleting one removes it, so an agent can keep a task list clean instead of leaving dead entries for people to wade through.
MCP servers that can download a file
Sometimes an agent needs the file itself, not a link or a preview: the actual bytes, to process, attach, or store elsewhere. Downloading a file pulls it from storage or a chat, so the agent can work with the content directly.
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 a task
Acting on a task means reading it first: its description, status, assignee, due date, the subtasks under it. Getting one task returns those details, so an agent can answer a question about it or work it from the full record rather than a title in a list.
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 account info
Before an agent acts on an account, it often needs to know the account itself: which one it is connected to, its status, what it can do. Getting account info returns those details, so the agent confirms the right account and reads its state before it transacts.
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 alerts
Alerts are the signals that something crossed a threshold, and an agent triaging system health reads them to see what is firing. Listing alerts returns what is currently raised, so the agent can summarize on-call status or decide what needs a response.
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 metrics
Before an agent can query a metric, it has to know which metrics exist. Listing metrics returns the available names, so the agent picks the right series, request latency, signups, error rate, rather than guessing at a metric that may not be there.
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 comments
Comments are where the discussion around a thing lives, and an agent that needs to catch up on a record, a design, or a page reads them. Listing comments returns that thread, so the model can summarize the conversation or answer from what people actually said.
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 webhooks
Webhooks are easy to create and easy to forget, so before an agent adds another or audits an integration, it lists the ones already registered. Listing webhooks returns what is configured and where it points, so the agent can see the wiring rather than guess at it.
MCP servers that can list customers
Customer-facing work usually starts from the list: who are the customers, which one is this, what is on their account. Listing customers returns them so an agent can find the right record before it bills, emails, or reports on someone.
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 databases
A database server often hosts many databases, and an agent has to know which exist before it queries one. Listing databases returns them, so the agent picks the right one to run a query against or to inspect its tables.
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 invoices
Invoices are the record of what was billed, and an agent that reconciles payments, chases an unpaid bill, or reports on revenue starts by listing them. Listing invoices returns what was issued and its status, so the agent works from the real billing history.
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 labels
Before an agent tags something or filters by category, it has to know which labels exist. Listing labels returns the available tags, so the agent applies a real one, urgent, bug, frontend, rather than inventing a near-duplicate that splits the bucket.
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 payments
Every charge leaves a record, and an agent reconciling revenue, investigating a dispute, or reporting on sales reads those records. Listing payments returns the transactions on the account, so the agent works from what actually moved rather than what was supposed to.
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 storage buckets
Object storage organizes everything into buckets, and an agent that uploads a file, reads one back, or audits what is stored first has to know which buckets exist. Listing buckets returns them, so the agent picks the right container before it reads or writes.
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 teams
Teams are how most platforms group people, and an agent that assigns work, reports on a group, or scopes an action by team first has to list them. Listing teams returns the groups in a workspace or org, so the agent can resolve a team name to the id its other tools want.
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 list workspaces
A workspace is the top-level container for a person's work on many tools: their boards, their tasks, their projects. Listing workspaces returns the ones an account can reach, so an agent knows which workspace to operate in before it drills into the work inside.
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 remove an image background
Cutting an image out from its background is one of those edits everyone needs and nobody enjoys doing by hand. A remove-background tool does it in one call: hand it an image, get back a transparent cutout, so an agent can prep a product shot or an asset without a designer in the loop.
MCP servers that can get logs
When something misbehaves, the logs are where the why lives. Getting logs pulls them from a service, a pod, a CI job, or a system, so an agent debugging a problem reads the actual output rather than guessing from a status code.
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 a database schema
Before an agent writes a query against an unfamiliar database, it has to understand the shape: what tables exist, what the columns are, how they index and relate. A schema-search tool explores that, so the agent maps the database first instead of guessing at names.
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 users
Sometimes an agent does not need the whole roster, just one person: find the user who matches a name or a handle. Searching users returns the matches for a query, so an agent can resolve a specific person to their account without listing everyone.
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 a dashboard
A dashboard is rarely right the first time: a panel needs adding, a query needs fixing, a layout needs rearranging. Updating one changes the existing board rather than building a new one, so an agent can refine a view in place instead of leaving stale or duplicate dashboards behind.
MCP servers that can update a page
A doc is rarely done when it is created. A spec gets revised, a runbook gets a new step, a wiki page gets corrected. Updating a page changes the content of one that already exists, so an agent can keep documentation current in place rather than creating a second version.
MCP servers that can update a task
Most of a task's life is edits: the status moves, the due date slips, someone reassigns it. Updating a task changes those fields on a task that already exists, so an agent can keep a board current as work progresses rather than only filing new tasks.
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.