Skip to content

Using Tallyfy MCP server with Claude (text chat)

Overview

Claude Desktop was the first AI assistant to offer native MCP integration. The current model family includes:

  • Claude Opus 4.5: Flagship model with strong coding and multi-hour reasoning
  • Claude Sonnet 4: Balanced performance with hybrid thinking modes
  • Claude Haiku 4: Fast model for lighter tasks
  • Claude Code: Works with VS Code, JetBrains, and GitHub Actions

This guide covers setting up Tallyfy’s MCP server with Claude Desktop, what works well, and where to expect limitations.

MCP architecture flow

Diagram

Key points:

  • The MCP server runs locally and uses stdio (standard input/output) - not network protocols
  • API authentication happens once at startup via the Bearer token in your environment variable
  • Claude auto-discovers tools from the MCP server and shows them with the hammer icon

Important: Claude Desktop vs Claude Computer Use

This article covers Claude Desktop’s text-chat MCP integration - natural language access to Tallyfy data via API. This differs from Claude Computer Use, which controls computer interfaces visually (mouse, keyboard, screenshots).

Key differences:

  • Claude Desktop + MCP (this article): Text chat connecting to APIs and data sources
  • Claude Computer Use: Visual control of desktop apps via screenshots and input actions

Use MCP for data queries, analysis, and API automation. Use Computer Use for visual UI tasks that need clicking and seeing interface elements.

Claude Desktop MCP support

Claude Desktop’s MCP features include:

  • Native MCP client with full protocol support
  • Desktop Extensions: One-click .mcpb installation bundling servers with all dependencies
  • Remote MCP servers: URL-based connection with OAuth 2.1, hosted on Cloudflare
  • Transport: stdio for local servers, Streamable HTTP for remote (SSE is deprecated)
  • Security: OS keychain integration (macOS Keychain, Windows Credential Manager)
  • Plans: Available on Pro, Max, Team, and Enterprise (not Free)
  • Platforms: macOS and Windows
  • Tool discovery: Auto-detects and displays available MCP tools
  • Governance: MCP is governed by the Agentic AI Foundation under the Linux Foundation (since December 2025)

Prerequisites

  • Claude Desktop installed (latest version with Desktop Extensions)
  • Tallyfy API key from your organization settings
  • For manual setup: Node.js 18+ and comfort editing JSON files
  • For Desktop Extensions: Just click install on any .mcpb file - no configuration needed

MCP tools and integrations

Official MCP servers

  • GitHub: Repos, issues, PR workflows
  • Stripe: Payment processing
  • PayPal: Inventory, payments, shipping, refunds
  • Slack: Team communication with Real-time Search API
  • Linear: Project management with OAuth remote MCP
  • Sentry: Error tracking
  • PostgreSQL, MySQL, MongoDB: Database operations with schema inspection
  • Filesystem: Local file access with sandboxed controls
  • Brave Search: Privacy-focused web search
  • Atlassian: Jira and Confluence via remote MCP
  • ServiceNow: Workflow automation

MCP directories

  • PulseMCP (pulsemcp.com): Large, regularly updated directory
  • mcpservers.org: Community collection synced with GitHub
  • MCP Market (mcpmarket.com): Figma, Databricks, Storybook connectors
  • mcp.so: Anthropic’s community platform with server registry

Setting up Tallyfy MCP server with Claude Desktop

  1. Install Claude Desktop

    Download from claude.ai/download for macOS or Windows.

  2. Find the configuration file

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

    Claude creates this file when you first edit the configuration.

  3. Create the Tallyfy MCP server

    Terminal window
    mkdir ~/tallyfy-mcp-server
    cd ~/tallyfy-mcp-server
    npm init -y
    npm install @modelcontextprotocol/sdk axios
  4. Write the server script

    Create tallyfy-server.js:

    const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
    const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
    const axios = require('axios');
    const TALLYFY_API_KEY = process.env.TALLYFY_API_KEY;
    const TALLYFY_API_URL = 'https://mcp.tallyfy.com';
    const server = new Server({
    name: 'tallyfy-mcp',
    version: '1.0.0',
    });
    server.setRequestHandler('tools/call', async (request) => {
    if (request.params.name === 'search_tasks') {
    const { query, status } = request.params.arguments;
    const response = await axios.get(`${TALLYFY_API_URL}/tasks`, {
    headers: { 'Authorization': `Bearer ${TALLYFY_API_KEY}` },
    params: { q: query, status }
    });
    return {
    content: [{
    type: 'text',
    text: JSON.stringify(response.data, null, 2)
    }]
    };
    }
    });
    server.setRequestHandler('tools/list', async () => {
    return {
    tools: [{
    name: 'search_tasks',
    description: 'Search for tasks in Tallyfy',
    inputSchema: {
    type: 'object',
    properties: {
    query: { type: 'string', description: 'Search query' },
    status: { type: 'string', enum: ['open', 'completed', 'all'] }
    }
    }
    }]
    };
    });
    const transport = new StdioServerTransport();
    server.connect(transport);
  5. Configure Claude Desktop

    Option A: Desktop Extensions (recommended)

    • Go to Claude Desktop Settings, then Extensions
    • Browse the directory or upload a .mcpb file
    • Click “Install Extension” - done

    Option B: Manual configuration Edit claude_desktop_config.json:

    {
    "mcpServers": {
    "tallyfy": {
    "command": "node",
    "args": ["/Users/username/tallyfy-mcp-server/tallyfy-server.js"],
    "env": {
    "TALLYFY_API_KEY": "your-tallyfy-api-key-here"
    }
    }
    }
    }

    Replace /Users/username/ with your home directory and add your Tallyfy API key.

  6. Restart Claude Desktop

    Fully quit (Cmd+Q on macOS) and relaunch.

  7. Verify the connection

    Look for the hammer icon at the bottom of the chat. Click it to see your Tallyfy tools.

    Test with:

    "Search for all open tasks in Tallyfy"

Practical examples

Task management

Find all tasks assigned to me due this week and create a summary report.

Claude will query Tallyfy via the search_tasks tool, filter by user and date range, format a structured report, and optionally save it locally via filesystem MCP.

Stalled process detection

Check for stalled processes in our "Customer Onboarding" template and suggest next actions.

Claude queries active processes, identifies tasks that haven’t progressed, analyzes blockers, and provides recommendations.

Bulk reassignment

Reassign all of John's open tasks to Sarah - he's on vacation.

Claude finds John’s tasks, filters for open status, reassigns them, and summarizes the changes.

Claude Desktop features for Tallyfy

Projects for persistent context

Claude Desktop’s Projects feature lets you create a project per workflow or client. Upload process docs once and reference them across sessions. Task history persists between conversations - ideal for managing processes that span weeks or months.

Projects also support memory - Claude extracts and saves key facts to maintain continuity. Extended thinking lets it work through multi-step problems, alternating between reasoning and tool calls.

Local file system integration

Unlike web-based AI, Claude Desktop can access your local files:

{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/username/Documents/Tallyfy"
]
}
}
}

This lets you read process docs from disk, export Tallyfy data to CSV, and sync local templates.

Tool composition

Connecting multiple MCP servers is where Claude Desktop gets powerful. Example multi-server workflow:

  1. Filesystem MCP reads a CSV of 50 new employees
  2. Tallyfy MCP creates onboarding processes for each
  3. Slack MCP notifies the HR team with status updates
  4. GitHub MCP creates IT access tickets

Developer tools

  • MCP server logs: ~/Library/Logs/Claude/ (macOS) or %APPDATA%\Claude\logs\ (Windows)
  • Built-in tool call debugging
  • Claude Code: VS Code and JetBrains extensions with inline diffs
  • Remote MCP servers on Cloudflare with OAuth - no local setup
  • GitHub Actions support for CI/CD workflows

Limitations

No visual interface

Claude Desktop is text-only. You can’t see Tallyfy’s visual process tracker, clickable flowcharts, or progress bars. You’ll get “75% complete” as plain text instead.

Workaround: Have Claude pull the data, then view it in Tallyfy’s web UI.

No real-time updates

MCP is request-response, not live streaming. There are no push notifications when tasks change - you must ask Claude to check.

Workaround: Schedule periodic checks or set up webhooks for urgent items.

Limited form handling

Rich forms become flat text. Multi-select dropdowns with 50 options get listed out. File uploads need a separate step. Date pickers become manual text entry.

Single identity

One API key means one identity. Everything runs as the key owner, you can’t switch accounts, and the audit trail shows a single person for all actions.

Best use cases

Morning workflow review

Show me all tasks due today, any overdue items, and processes needing my attention. Create a prioritized action list.

Process analysis

Analyze the last 50 completed 'Customer Onboarding' processes. Find the steps with longest completion times and suggest improvements.

Documentation generation

Generate an SOP document for our 'Invoice Processing' template with all steps, responsible parties, and average completion times.

Task routing

Review team member skills and current workload, then suggest optimal task assignments for next week's projects.

Compliance reporting

Create a compliance report showing all 'Data Access Request' processes from last quarter, including completion times and SLA violations.

Combining MCP with Computer Use

Pair Claude’s text-based MCP with Claude Computer Use for broader automation:

MCP handles: API data queries, bulk operations, report generation, data-driven decisions

Computer Use handles: Visual interfaces, third-party form filling, UI navigation, apps without APIs

Example hybrid workflow

Step 1 - MCP (data gathering):

Analyze all completed audit processes this month, identify non-compliance issues, and export a summary with statistics to CSV.

Step 2 - Computer Use (visual automation):

Open the government compliance portal, navigate to the monthly report section, and fill in the form using the CSV data. Screenshot each step for audit trail.

Hybrid best practices

  1. MCP for data - API access is faster and more reliable than UI automation
  2. Computer Use for UI-only tasks - only when there’s no API available
  3. Files for data transfer - pass data between MCP and Computer Use via local files
  4. Watch costs - Computer Use with screenshots costs more than MCP API calls
  5. MCP is more predictable - API operations are deterministic; visual automation isn’t

Security

  1. Configuration security

    • Desktop Extensions encrypt credentials via OS secure storage (Keychain, Credential Manager)
    • Mark fields as "sensitive": true in manifest.json for auto-encryption
    • Store API keys in environment variables, not plaintext JSON
    • Set file permissions: chmod 600 claude_desktop_config.json
  2. MCP server isolation

    • Run servers with minimal permissions
    • Remote MCP uses OAuth 2.1 with PKCE. Tallyfy’s endpoints:
      • Authorization: https://go.tallyfy.com/mcp/oauth/authorize
      • Token: https://go.tallyfy.com/mcp/oauth/token
      • Dynamic Client Registration: https://go.tallyfy.com/mcp/oauth/register
    • OAuth discovery via /.well-known/oauth-authorization-server (RFC 8414)
    • Available scopes follow the pattern mcp.{resource}.{action} - for example: mcp.tasks.read, mcp.tasks.write, mcp.processes.read, mcp.templates.write, mcp.users.read, mcp.forms.read, mcp.automation.write
    • Log all API calls with timestamps for auditing
  3. Data handling

    • Claude Desktop stores conversations locally in ~/Library/Application Support/Claude/
    • Projects maintain persistent context - review what you’re sharing
    • Consider GDPR/CCPA compliance when handling user data
  4. Network security

    • HTTPS required for all API communications
    • Remote MCP eliminates local attack surface but needs internet
    • Implement exponential backoff for retries

Advanced configuration

Multiple MCP servers

Claude Desktop supports multiple simultaneous MCP connections:

{
"mcpServers": {
"tallyfy": {
"command": "node",
"args": ["~/tallyfy-mcp-server/server.js"],
"env": { "TALLYFY_API_KEY": "key-1" }
},
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "~/Documents"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_TOKEN": "ghp_xxx" }
}
}
}

Custom server tips

  1. Use TypeScript for type safety

    import { Server } from '@modelcontextprotocol/sdk/server/index.js';
    import { TallyfyClient } from './tallyfy-client';
  2. Handle errors properly

    try {
    const result = await tallyfyApi.call();
    return { content: [{ type: 'text', text: result }] };
    } catch (error) {
    return {
    error: {
    code: 'TALLYFY_API_ERROR',
    message: error.message
    }
    };
    }
  3. Add request logging

    console.error(`[Tallyfy MCP] ${new Date().toISOString()} - ${request.method}`);

Known issues

  1. Windows paths: Use forward slashes / or double backslashes \\ in JSON configs
  2. Large datasets: Paginate when pulling 1000+ items - Claude truncates big responses
  3. Idle disconnects: Implement retry logic with exponential backoff
  4. Memory growth: Restart Claude Desktop periodically during heavy use
  5. Rate limits: Vary by plan tier - track your usage
  6. SSE deprecated: Use Streamable HTTP for new integrations
  7. Remote MCP needs internet: Local stdio servers work offline; remote ones don’t

Claude vs ChatGPT for MCP

Claude Desktop:

  • Mature MCP implementation with Desktop Extensions (.mcpb)
  • Remote MCP on Cloudflare with OAuth
  • Extended thinking with tool use
  • Computer Use for hybrid automation

ChatGPT/OpenAI:

  • MCP in Agents SDK with Responses API
  • Desktop MCP for Team/Enterprise with custom connectors
  • Deep Microsoft integration (Teams, Office, Azure)

Choose Claude for the most mature MCP experience, Desktop Extensions, Projects for persistent context, and Computer Use hybrid workflows. Consider ChatGPT for Microsoft integration or enterprise admin-controlled connectors.

Best practices

  1. Start with read-only operations before adding write capabilities
  2. Test in sandbox - never test against production Tallyfy data
  3. Document tools with clear descriptions and inputSchema definitions
  4. Version your servers using semantic versioning in manifest.json
  5. Track API usage - Claude enforces rate limits per plan
  6. Package as .mcpb for easy distribution via Desktop Extensions
  7. Return proper error codes - not raw exceptions

Byo Ai > Claude integration

Claude connects to Tallyfy’s MCP server at https://mcp.tallyfy.com using OAuth 2.1 with PKCE so you can manage tasks and processes and templates and automations through natural language in both Claude.ai web and Claude Desktop without writing any API calls.

Integrations > MCP server

Tallyfy’s MCP Server lets you control workflows through AI assistants like ChatGPT, Claude, and Gemini - searching tasks, managing processes, editing templates, and building automations using plain English instead of API calls.

Mcp Server > Using Tallyfy MCP server with ChatGPT

ChatGPT Enterprise Team and Education users can connect to Tallyfy’s MCP server using OAuth 2.1 with PKCE to manage workflows through natural language with full read/write capabilities via Developer Mode though the text-based interface has limitations for visual workflows form interactions and real-time collaboration making it best suited for complex searches analysis automation planning and template optimization.

Mcp Server > Using Tallyfy MCP server with Microsoft Copilot Studio

Microsoft Copilot Studio connects to Tallyfy’s hosted MCP server through Power Platform custom connectors and OpenAPI specs to enable enterprise-grade multi-agent workflow automation with VNet isolation and DLP policies and deep Microsoft 365 integration for managing tasks and processes through natural language.