One AI Chat to Rule Them All: Connecting Enterprise Tools with MCP by Karthik Sayapparaju
(link)Summary
This talk explains why LLMs need a standardized way to access external tools and shows how [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) addresses that gap. Instead of copy-pasting context into prompts or building one-off integrations for every service, MCP lets a host app expose structured tools through MCP servers maintained by the tool providers or by you. Using examples from Mattermost and Jira, the talk demonstrates how an LLM can read channel messages, summarize issues, and create tickets through tool calls. It also touches on emerging UI patterns, including richer interactive components rendered in the host application, and closes with a personal example of using MCP to automate note-taking in Obsidian.
Key Takeaways
- LLMs in host apps are limited without access to external tools, memory, and actions.
- MCP standardizes how host apps discover and call tools exposed by MCP servers.
- Tool schemas and descriptions are injected into the model context so the LLM can choose the right capability.
- Real examples include reading Mattermost messages and creating Jira tickets from inferred issues.
- MCP can support richer experiences beyond text, including interactive UI components in the host app.
- The protocol may reduce the need for custom integrations by providing a common interface for enterprise systems.
Sections
Why LLM apps need tool access
The talk starts with a simple example: an AI can plan a run route, but it cannot act on the user’s behalf, such as creating a calendar event or fetching live data from another service. This highlights two common problems in AI applications: missing context and missing actionability. Copy-pasting context is tedious, retrieval-augmented generation only helps with finding information, and custom integrations do not scale when every external service needs its own adapter.
What MCP is and how it works
Model Context Protocol is presented as a standard layer between a host application and external services. The host app contains the AI logic and an MCP client. That client connects to MCP servers, which expose capabilities in a structured way and handle the actual API calls to underlying services. The protocol was introduced by Anthropic in late 2024, later donated to the Linux Foundation, and has support from major vendors such as OpenAI, Google, and Microsoft.
Handshake, tools, and context injection
At startup, the MCP client and server perform a handshake. The server advertises its capabilities, such as tools for fetching, creating, or patching resources. These tool definitions, including schemas and descriptions, are injected into the LLM context. The talk emphasizes that the tool description is crucial because the model uses it to decide whether a tool should be called for a given user request.
Demo: Mattermost messages to Jira tickets
A live demo shows a local Mattermost MCP server and a remote Atlassian/Jira integration. The host app, Open WebUI, is connected to both. The user asks for a summary of a Mattermost channel, and the model calls the message-fetching tool to retrieve the discussion. When asked to create tickets for the issues mentioned in the chat, the model then calls the Jira tool and creates tickets automatically, demonstrating end-to-end tool use through MCP.
Beyond text: richer host-app experiences
The talk closes by looking at where MCP could go next. Instead of only returning text, host applications could render interactive components or visual elements. Examples include booking an Uber from an embedded UI or exploring a 3D map for a city guide. The speaker suggests that tighter security and more expressive UI patterns will likely emerge as the ecosystem matures.
Personal use case: Obsidian automation
The speaker shares an idea for using MCP with Obsidian to automate note creation. After technical conversations or general Q&A, the AI could summarize the discussion and create a structured note directly in the user’s vault. This shows how MCP can connect conversational AI to everyday productivity tools without manual copy-paste workflows.
Keywords: model context protocol, mcp, ai tool calling, llm host applications, mcp server, enterprise integrations, mattermost integration, jira automation, open webui, anthropic mcp, tool schemas, context injection, retrieval augmented generation, rag, obsidian automation, ai agents, structured tool calls, external api integration, linux foundation, interactive ai ui