KnowHow

Building an MCP host that connects Howie to third-party tools

The problem

Agent Howie is built on Claude, giving it strong reasoning capabilities, but its usefulness is limited by the tools and data available to it. This means clients still need to leave the platform to access information and complete tasks.

The solution

Add MCP support to Agent Howie, allowing it to securely connect with external tools and data sources. This expands what clients can accomplish directly within the platform and reduces the need to switch between tools.

ClientHowieMCP

How it’s built

Connecting a tool is a one-time OAuth exchange, and the same flow serves any provider. The user is sent to that provider’s consent screen, a signed callback authorizes the exchange, and the tokens come back encrypted at rest. Only then does the connector report itself as connected.

From there Howie can reach anything connected. Every tool call the agent makes goes through a guarded node first, which validates the request against the set of tools that have been permitted. A call for anything outside that set is blocked before an MCP session is opened, so it never reaches the provider at all. Results return along the same path and into the chat.

Three records back it: McpConnector for connection status, McpConnectorCredential for the encrypted tokens, kept apart from the connector itself, and McpToolCallLog for the latency and outcome of every call, so which tools the agent actually reached is auditable rather than just asserted.

None of that is written per provider. Adding one means registering another MCP server and the scopes it needs; the agent’s core logic, the guard, and the storage stay as they are.

Three bands. Connection: the user connects, the provider’s consent screen requests the scopes, a signed callback authorizes the exchange, tokens are stored encrypted, and the connector becomes connected. Runtime: Howie calls a guarded tool node that validates every call against the set of permitted tools, blocking anything that is not approved, then opens an MCP session to the connected tool, with results returning to the chat. Storage: McpConnector for connection status and provider, McpConnectorCredential for encrypted tokens, and McpToolCallLog for tool-call observability.Connection (one-time OAuth)Connectuser actionConsent screenscopes requestedAuthorizesigned callbackTokens storedencrypted at restConnectedconnector statusRuntime (every tool call)HowieLangGraph agentGuarded tool nodepermitted tools onlyMCP sessionper callConnected toolany MCP serverStorageMcpConnectorconnection status · providerMcpConnectorCredentialencrypted tokensMcpToolCallLogtool-call observabilityonce connectedresults back into chatreads credentials · writes logs

Demo

Here’s the system in action, from connecting a tool to using it inside a conversation. Watch how a user links an integration through a single consent flow, then how the agent pulls real data into chat, only ever calling tools that have been approved.

What makes this more than a simple integration is that every tool call passes through the same gate, so the agent can reach external tools while staying inside clear boundaries. The same flow works for any provider, which means new tools can be added without changing how the agent thinks.

Footnotes

Built during my internship at KnowHow. Shoutout Eleazar Maestre, Pedro Restrepo Martinez, and Theo Wall for all the support on this project.