Using Tallyfy MCP Server with Claude (Text Chat)
Claude Desktop pioneered MCP support back in November 2024. It’s the first AI assistant that lets you connect directly to Tallyfy workflows, local files, and external tools - all through natural language.
We’ll walk you through setting up Tallyfy’s MCP server with Claude Desktop, show you what works (and what doesn’t), and help you get the most out of this integration.
Important: Claude Desktop vs Claude Computer Use
This article covers Claude Desktop’s text-chat interface with MCP integration - where you interact with Claude through natural language to access Tallyfy data via MCP servers. This is different from Claude Computer Use, which allows Claude to visually perceive and control computer interfaces (mouse, keyboard, screenshots).
Key differences:
- Claude Desktop + MCP (this article): Text-based chat that connects to data sources and APIs
- Claude Computer Use: Visual perception and control of desktop applications through screenshots and mouse/keyboard actions
Both can work with Tallyfy, but serve different purposes:
- Use Claude Desktop + MCP for data queries, analysis, and API-based automation
- Use Claude Computer Use for automating visual UI tasks that require seeing and clicking interface elements
As of January 2025, Claude Desktop’s MCP implementation includes:
- Native support: Built-in MCP client with full protocol support
- Transport methods: Standard input/output (stdio) for local servers, HTTP/SSE for remote servers
- All Claude plans: Available for all Claude.ai subscription tiers (Free, Pro, Team)
- Operating systems: macOS and Windows (Linux support coming soon)
- Dynamic tool discovery: Automatic detection and display of available MCP tools
Claude Desktop remains the gold standard for MCP implementation - everyone else is playing catch-up.
You’ll need these four things:
- Claude Desktop app installed (latest version)
- Tallyfy API key (grab it from your organization settings)
- Node.js version 16 or higher
- Basic comfort with editing JSON files
-
Install Claude Desktop
Download Claude Desktop from claude.ai/download ↗ for your operating system (macOS or Windows).
-
Locate the configuration file
The MCP configuration file location varies by operating system:
- macOS:
~/Library/Application Support/Claude/claude_desktop_config.json
- Windows:
%APPDATA%\Claude\claude_desktop_config.json
If the file doesn’t exist, Claude will create it when you first edit the configuration.
- macOS:
-
Create the Tallyfy MCP server
First, create a local directory for your MCP server:
Terminal window mkdir ~/tallyfy-mcp-servercd ~/tallyfy-mcp-servernpm init -ynpm install @modelcontextprotocol/sdk axios -
Implement the server script
Create a file named
tallyfy-server.js
:const { Server } = require('@modelcontextprotocol/sdk/server/index.js');const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');const axios = require('axios');// Initialize Tallyfy API clientconst 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',});// Tool to search for tasksserver.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)}]};}});// List available toolsserver.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'] }}}}]};});// Start the serverconst transport = new StdioServerTransport();server.connect(transport); -
Configure Claude Desktop
Edit your
claude_desktop_config.json
file:{"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 actual home directory pathyour-tallyfy-api-key-here
with your Tallyfy API key
-
Restart Claude Desktop
Completely quit Claude Desktop (Cmd+Q on macOS or close all windows on Windows) and relaunch it.
-
Verify the connection
Look for the tools icon (🔨) at the bottom of Claude’s chat interface. Click it - you should see your Tallyfy tools listed there.
Try this test query:
"Search for all open tasks in Tallyfy"
User prompt:
Find all tasks assigned to me that are due this week and create a summary report.
Claude with MCP will:
- Use the
search_tasks
tool to query Tallyfy - Filter results for current user and date range
- Format findings into a structured report
- Optionally save the report locally using filesystem MCP
User prompt:
Check if there are any stalled processes in our "Customer Onboarding" template and suggest next actions.
Claude with MCP will:
- Query for active processes using the template
- Identify tasks that haven’t progressed recently
- Analyze blockers based on task data
- Provide specific recommendations
User prompt:
Reassign all of John's open tasks to Sarah due to his vacation.
Claude with MCP will:
- Search for all tasks assigned to John
- Filter for open status
- Execute bulk reassignment to Sarah
- Provide a summary of changes made
Claude Desktop’s Projects feature is a game-changer for workflow management. Create a project for each major workflow or client, and Claude remembers everything. Upload process docs once, reference them forever. Your task history stays put between sessions. It’s perfect when you’re managing ongoing processes that span weeks or months.
Web-based AI tools can’t touch your local files. Claude Desktop can:
{ "mcpServers": { "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "/Users/username/Documents/Tallyfy" ] } }}
What can you do with this? Plenty:
- Read process documentation straight from your hard drive
- Export Tallyfy data to CSV files (hello, Excel reports)
- Sync local templates with Tallyfy in seconds
Claude Desktop really shines when you connect multiple MCP servers. Watch this:
Real workflow we built last week:
- Filesystem MCP reads a CSV of 50 new employees
- Tallyfy MCP creates onboarding processes for each one
- Slack MCP pings the HR team with status updates
- GitHub MCP automatically creates IT access tickets
Developers, you’re in for a treat:
- MCP server logs live in
~/Library/Logs/Claude/
- Watch tool calls happen in real-time
- Test your custom MCP servers without breaking anything
Let’s be honest about what Claude Desktop can’t do:
The problem: Claude Desktop lives in text. No pretty pictures.
What you lose:
- Can’t see Tallyfy’s visual process tracker
- No clickable flowcharts or diagrams
- Progress bars? You get “75% complete” in plain text
Fix it: Have Claude generate the data, then visualize it in Tallyfy’s web interface.
The problem: MCP works like email, not instant messaging.
What’s missing:
- No live alerts when tasks change
- You have to ask Claude to check for updates
- Can’t watch processes update in real-time
Fix it: Schedule periodic checks or set up webhooks for the urgent stuff.
The problem: Fancy forms become plain text nightmares.
Real examples that hurt:
- Multi-select dropdown with 50 options? You’re listing them all
- Need to upload a file? That’s a separate workflow
- Date picker? Type “2025-03-15” and hope you get the format right
The problem: One API key = one identity.
The reality check:
- Everything happens as the API key owner
- Can’t switch between user accounts
- Your audit trail shows one person doing everything (spoiler: it’s you)
Strength: Quick status checks and prioritization.
Example routine:
"Good morning! Show me all tasks due today, any overdue items, and processes that need my attention. Create a prioritized action list."
In 30 seconds, you’ve got your entire day mapped out.
Strength: Deep analysis of workflow patterns.
Example:
"Analyze the last 50 completed 'Customer Onboarding' processes. Identify the steps with longest completion times and suggest optimizations."
Claude spots the bottlenecks you’ve been missing for months.
Strength: Creating comprehensive process documentation.
Example:
"Generate a detailed SOP document for our 'Invoice Processing' template, including all steps, responsible parties, and average completion times."
Your 20-page SOP document? Done in 2 minutes.
Strength: Complex decision-making for task assignments.
Example:
"Review the skills and current workload of team members, then suggest optimal task assignments for the next week's projects."
No more playing favorites - Claude assigns work based on actual capacity and skills.
Strength: Generating audit-ready reports.
Example:
"Create a compliance report showing all 'Data Access Request' processes from last quarter, including completion times and any SLA violations."
Auditor coming tomorrow? Your compliance report is ready today.
Here’s where things get interesting. Combine Claude’s text-based MCP with Claude Computer Use, and you’ve got automation superpowers:
Claude MCP excels at:
- Querying and analyzing Tallyfy data via API
- Bulk operations across multiple records
- Generating reports and insights
- Making data-driven decisions
Claude Computer Use excels at:
- Interacting with visual interfaces
- Filling forms in third-party applications
- Navigating complex UI workflows
- Handling applications without APIs
Scenario: Monthly compliance reporting requiring both data analysis and visual form submission.
Step 1: Claude MCP
"Analyze all completed audit processes this month, identify any non-compliance issues, and prepare a summary report with statistics."
Step 2: Claude Computer Use
"Open the government compliance portal in the browser, navigate to the monthly report section, and fill in the form with the statistics from the report."
- Use MCP for data operations: Leverage API access for efficient data retrieval and processing
- Use Computer Use for UI-only tasks: Reserve visual automation for applications without API access
- Pass data between modes: Use files or clipboard to transfer data between MCP and Computer Use sessions
- Monitor costs: Computer Use with screenshots is more expensive than MCP API calls
- Design for reliability: MCP operations are more deterministic than visual UI automation
When designing workflows that use both capabilities:
- Start with MCP for data gathering and preparation
- Switch to Computer Use only when visual interaction is required
- Return to MCP for final data validation and storage
- Document which parts of the workflow use which capability
- Test failure points and implement appropriate fallbacks
Mix these approaches right, and you can automate workflows that seemed impossible last year.
Don’t skip this part - security matters:
-
Local configuration security
- Store API keys in environment variables, not plaintext
- Restrict file permissions on
claude_desktop_config.json
- Use separate API keys for different environments
-
MCP server isolation
- Run MCP servers with minimal permissions
- Implement request validation in your server code
- Log all API calls for audit purposes
-
Data handling
- Be cautious about sensitive data in conversations
- Claude Desktop stores conversation history locally
- Consider data retention policies
-
Network security
- Use HTTPS for all API communications
- Implement request rate limiting
- Monitor for unusual access patterns
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" } } }}
-
Use TypeScript for better type safety
import { Server } from '@modelcontextprotocol/sdk/server/index.js';import { TallyfyClient } from './tallyfy-client'; -
Implement comprehensive error handling
try {const result = await tallyfyApi.call();return { content: [{ type: 'text', text: result }] };} catch (error) {return {error: {code: 'TALLYFY_API_ERROR',message: error.message}};} -
Add request logging for debugging
console.error(`[Tallyfy MCP] ${new Date().toISOString()} - ${request.method}`);
- Windows paths are weird: Use forward slashes or double backslashes (\\)
- Too much data crashes things: Paginate when pulling 1000+ items
- Connections drop randomly: Add retry logic - trust me on this
- Memory leaks happen: Restart Claude Desktop every few hours
- Start simple: Begin with read-only operations before implementing modifications
- Test thoroughly: Use a Tallyfy sandbox environment during development
- Document your tools: Provide clear descriptions for each MCP tool
- Version your servers: Include version numbers in your MCP server implementations
- Monitor usage: Track API calls to optimize performance and costs
What’s coming next for Claude Desktop MCP? Good stuff:
- Streaming responses: Real-time data without the wait
- Visual previews: Finally, some charts and graphs (maybe)
- Plugin marketplace: Share your MCP servers with the world
- Better auth: OAuth flows so you’re not stuck with one API key
Claude Desktop + Tallyfy MCP isn’t perfect. You won’t get pretty pictures or instant updates. But for workflow analysis, task management, and turning data into decisions? It’s unbeatable.
Set it up once, and you’ll wonder how you managed workflows without it. The 20 minutes you spend configuring MCP will save you 20 hours next month.
Mcp Server > Using Tallyfy MCP Server with ChatGPT
Mcp Server > Using Tallyfy MCP Server with Microsoft Copilot Studio
- 2025 Tallyfy, Inc.
- Privacy Policy
- Terms of Use
- Report Issue
- Trademarks