MCP for Beginners: What It Is, Why It Matters, and How to Try Your First One

TL;DR

MCP (Model Context Protocol) is the open standard, published by Anthropic in late 2024, that lets any AI host (Claude Desktop, Cursor, Windsurf, your script) call any external tool surface through one consistent JSON-RPC interface. Think USB-C for LLMs. Beginners try their first MCP by editing one config file, restarting the host, and asking "what tools do you see?" in chat. Fintalio is one example: a hosted MCP server exposing 19 LinkedIn-prospecting tools at https://fintalio.com/mcp.

What does "MCP" stand for and why does it exist?

MCP is the Model Context Protocol. Anthropic published it as an open standard in November 2024 (see the official announcement).

The problem it solves is real. Before MCP, every AI host had its own way to connect external tools. OpenAI had "function calling." Claude had "tools." Each IDE and chat app rolled its own wrapper. Building a tool surface that worked everywhere meant writing four integrations.

MCP collapsed that into one protocol. The analogy that sticks: USB-C. One cable. Many devices. Same connector.

MCP is not Anthropic-exclusive, despite Anthropic publishing it. The open-source agent ecosystem is adopting it broadly through 2025-2026. Verify the current adoption status of any specific vendor (OpenAI, Google) at the time you read this, because announcements move fast.

The 4-line plain-English explanation

Strip the jargon and MCP fits in four lines.

An MCP host runs an LLM. Claude Desktop is a host. Cursor is a host. Windsurf is a host. Your custom script can be a host.

An MCP server publishes tools, resources, and prompts at an HTTPS endpoint. Fintalio is a server. GitHub's reference server is a server. The filesystem reference server is a server.

The host fetches the server's tool list at startup. This is the handshake. The host sees what is available without you writing custom code per server.

The LLM picks which tool to call. The host routes the call. The server returns a result. The LLM reads the result and decides what to do next.

That is the whole protocol. Everything else is implementation detail.

Architecture: one protocol, many possible servers

+----------------+   MCP/JSON-RPC over HTTPS    +-------------------+
|  MCP host      |  ---- list tools ---->        |  MCP server       |
|  (Claude       |  <---- tool definitions ----  |  (Fintalio,       |
|   Desktop,     |                                |   GitHub MCP,     |
|   Cursor, ...) |  ---- call tool ------->      |   your script...) |
+----------------+  <---- result -------------   +-------------------+
       ^                                                   |
       |                                                   v
   LLM picks tool                              external service
   to call next                              (LinkedIn, GitHub, DB)

The host knows nothing specific about LinkedIn. It only knows "there is a server at this URL with these tools." Same code path reads a filesystem server, a GitHub server, or Fintalio.

One host can attach multiple servers. The same Claude Desktop config can declare Fintalio for LinkedIn and the GitHub MCP for code at the same time. The LLM picks per turn from the combined tool menu.

MCP vs an API: what's actually different?

Worth pulling apart because beginners conflate them.

An API is a tool-specific contract. You write client code per API. LinkedIn's API has its endpoints. GitHub's API has its endpoints. Each integration is its own project.

MCP is a tool-agnostic contract. One host code-path reads any compliant MCP server. The integration work shifts to the server side, once, and every compliant host benefits.

An API serves humans and scripts. MCP is shaped for LLMs. Tool definitions are typed. Argument schemas are discoverable. Results are structured for downstream LLM reasoning.

The two can coexist. Fintalio exposes a REST API for scripts and an MCP endpoint at /mcp for LLM agents. The underlying actions are the same: list contacts, create a sequence, launch outbound. The API and the MCP surface are two ways to reach the same workflow.

Three real MCP servers you might attach (a tour)

Beginners learn by attaching one server. Here are three to consider.

Filesystem MCP (Anthropic reference). Read and write local files via the LLM. Most common "hello world" for MCP. Anthropic ships reference implementations on GitHub.

GitHub MCP (Anthropic reference). Query issues, pull requests, and file contents. Useful if your workflow already lives on GitHub.

Fintalio MCP (LinkedIn prospecting). 19 tools (9 read, 9 write, 1 execute) for LinkedIn outbound: list contacts, parse CSVs, create sequences, launch campaigns (the last one is human-gated). Hosted, no DIY infrastructure required.

Pick the one closest to your workflow. The protocol is the same. Attaching the first one teaches you everything you need for the next ten.

The Fintalio LinkedIn example, concretely

If you pick Fintalio as your first server, here is what you are attaching.

Endpoint: https://fintalio.com/mcp.

Auth: a Sanctum personal access token issued in the Fintalio dashboard (Settings, "Tokens API & MCP"). The token format is a 60-character string, per the Sanctum documentation.

Tools available (these match app/Mcp/Servers/FintalioServer.php exactly):

Read tools (9): ListContacts, GetContact, ListContactGroups, ListSequences, GetSequence, ListSequenceTemplates, GetSequenceTemplate, ListVariables, GetAccountStatus.

Write tools (9): CreateContactGroup, UpdateContact, PauseSequence, ResumeSequence, StopSequence, ParseCsv, CommitCsv, CreateSequenceTemplate, CreateContact.

Execute tool (1): LaunchSequence.

Resources (3): ContactResource, SequenceResource, TemplateResource.

Pricing: single plan €69/mo. MCP access bundled. No separate tier. No free tier.

Your first 10-minute MCP exercise (any host)

Eight steps. We will use Claude Desktop because Anthropic's docs are the clearest beginner path. The same flow works for Cursor or Windsurf with different config file paths.

Step 1: install Claude Desktop. Free or paid Anthropic plan, your choice.

Step 2: get a Fintalio token. Sign up at fintalio.com/register on the single €69/mo plan. Settings, "Tokens API & MCP," "New token," name it claude-desktop-mac. Copy the value the moment it appears. Sanctum tokens are shown once.

Step 3: find Claude Desktop's config file.

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

If the file does not exist, create it. If it does and already has an mcpServers block, merge into it. Do not overwrite.

Step 4: paste this block.

{
  "mcpServers": {
    "fintalio": {
      "url": "https://fintalio.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN_HERE"
      }
    }
  }
}

Step 5: replace YOUR_TOKEN_HERE with the 60-character Sanctum token from Step 2. Keep the word Bearer. Keep the space.

Step 6: save the file. JSON is unforgiving about commas and quotes. Run it through a JSON linter if Claude Desktop refuses to load it later.

Step 7: full quit Claude Desktop and relaunch. Closing the window is not enough. Claude Desktop reads claude_desktop_config.json only on cold start.

Step 8: in a fresh chat, type: "List the LinkedIn MCP tools you can see from Fintalio."

You should see the 19 tools enumerated, plus 3 resources. If you do not, check the JSON syntax and the token. If both are correct, the failure is in the host (older Claude Desktop versions had quirks). This is your first "MCP works on my machine" moment.

The boring 80% the protocol solves

Five things you do not have to write.

Tool discovery: the host learns what is available without custom code per server.

Tool calling: the LLM picks. The host routes. The server returns. Uniform across servers.

Auth and rate limiting: standardized through bearer tokens (Fintalio uses Sanctum) plus server-side throttles (Fintalio enforces 120 req/min per token in routes/ai.php).

Error handling: structured response codes. The LLM can react cleanly to a 429 or a 4xx.

Schema typing: tool arguments are typed. The LLM does not have to guess shapes.

That is the 80%. Solved by the protocol and the server. You write none of it.

The interesting 20% you still control

Four things that stay yours.

Which servers to attach. Your stack choice. Filesystem, GitHub, Fintalio, your own. The combination is the agent's reach.

Which prompts to write. Your agent design. The same Fintalio tool surface can support sourcing, sales, recruiting, or partnerships workflows depending on the prompts.

Which actions are "go ahead" vs "pause for me." Your governance. For Fintalio specifically, LaunchSequence should always be human-gated. It is the action that triggers real outbound to real prospects.

How you log and audit. The host plus a tracer of your choice (Langfuse, LangSmith, Helicone) plus the server's per-call log.

What MCP is NOT (common misunderstandings)

Four things people assume MCP is, and is not.

It is not a hosted-LLM API. Anthropic still sells access to Claude separately. MCP is the tool-protocol layer. The LLM is a separate purchase.

It is not an agent framework. LangChain, CrewAI, and similar frameworks sit on top of MCP. MCP is the protocol that lets the framework talk to tools.

It is not exclusive to Anthropic models. Any LLM provider can be the underlying model in any MCP host. Verify the current model support in your host's docs.

It is not a magic "your AI can do anything." The tools are exactly what the server publishes. Fintalio publishes 19. No more, no less. If the LLM proposes SearchProfiles, SendMessage, ReadInbox, PublishPost, ReadFeed, ScrapeProfile, AdvancedSearch, or WebhookSubscribe, it is hallucinating. None of those exist on Fintalio's surface.

Common beginner mistakes

Five we see repeatedly. None of them require advanced debugging once you know to look.

Editing the config file with a missing comma. JSON is unforgiving. Use a linter.

Pasting the token but forgetting the word Bearer in the Authorization header. The server rejects the call.

Closing the window instead of full quit before testing. Claude Desktop reads config only on cold start. Cmd+Q on macOS. System tray quit on Windows.

Asking the LLM to call tools that do not exist. The 19 Fintalio tools are the only real ones on Fintalio's surface. Anything else is the LLM filling in plausible-sounding names.

Assuming MCP works in Claude.ai (the web app) the same way it works in Claude Desktop. The two are different surfaces today. Verify each host's MCP support at the time you set up.

The 80/20 of getting started

80% of your "what is MCP" learning is solved by attaching one real server and asking it for its tool list. The protocol becomes concrete the moment you see the tools enumerate in chat.

20% is the design decisions: which servers, which prompts, which gates. That is where the depth lives, and where the deeper articles in this blog go.

Do not read 5,000 words of theory first. Do the 10-minute exercise. Then read the deeper articles.

Where to go next

Three reading paths, depending on what you want.

For the deeper protocol explainer, read the pillar LinkedIn MCP architecture.

For the tactical Claude Desktop tutorial, see Build a LinkedIn AI Agent in Claude Desktop. For the Cursor variant, see Cursor + LinkedIn MCP workflow. For the Windsurf variant, see Windsurf + LinkedIn MCP workflow.

For the MCP vs API protocol distinction, see MCP vs API: the LinkedIn case. For a landscape view of the MCP ecosystem, see Best MCP servers in 2026.

FAQ

Do I need to know how to code to use MCP?

No. The first 10-minute exercise requires only editing one JSON config file and copying a token from a dashboard. The deeper work (building your own MCP server, writing agent loops in Python or TypeScript) does require code. Many MCP users are happy with the no-code attach-a-server flow and never write a line of agent code.

Is MCP only for Anthropic / Claude models?

No. MCP is an open standard. Any compliant host can use any compliant server, regardless of which underlying LLM provider the host uses. Verify the current model support in your host's documentation. Adoption beyond Anthropic is expanding through 2025-2026, with announcements from major model providers and tool vendors throughout the year.

What's the cheapest way to try MCP?

The Anthropic reference servers (filesystem, GitHub) are free to attach to a free or paid Claude Desktop plan. That is the cheapest "hello world." For a hosted external server like Fintalio (LinkedIn prospecting), the single plan is €69 per month with bundled MCP access. There is no free Fintalio tier; the protocol itself is free.

Can MCP servers see my private data?

A server sees only the calls the host makes. If the LLM never calls a tool that reads your data, that data stays where it is. For Fintalio, the agent reads LinkedIn contact data only when the recruiter or SDR triggers a read call. The server does not pull data autonomously. Verify your specific server's privacy posture at signup.

Is MCP going to be replaced by something else in 6 months?

Protocols are sticky once adopted broadly, and MCP has broad 2025-2026 adoption across hosts and ecosystems. Replacement in 6 months is unlikely. Evolution within the protocol (new features, extensions) is happening continuously. Read the spec changes on modelcontextprotocol.io quarterly if you are building production agents.

Conclusion

MCP is USB-C for LLMs. One protocol. Many hosts. Many servers. The LLM picks, the host routes, the server returns.

Your first exercise takes 10 minutes. Edit one config file. Paste one token. Restart the host. Ask "what tools do you see?" in chat. That is the protocol becoming concrete.

The 80% is solved by the spec and the server. The 20%, your stack choice, your prompts, your gates, stays with you.

If you want to keep using Fintalio as your LinkedIn MCP server, register on the single €69/mo plan. MCP access is bundled. Education first. Commercial second. The 19 tools are waiting either way.