smartsheet-server

MCP server providing healthcare analytics capabilities for Smartsheet, including clinical note summarization, patient feedback analysis, and research impact assessment

12 stars PythonOthers Updated Jun 19, 2026

azure-openaibatch-processingclinical-researchhealthcare-analyticshealthcare-automationmcp-servermedical-researchsmartsheetpatient-feedback

Documentation

Smartsheet MCP Server

A Model Context Protocol (MCP) server that provides seamless integration with Smartsheet, enabling automated operations on Smartsheet documents through a standardized interface. This server bridges the gap between AI-powered automation tools and Smartsheet's powerful collaboration platform.

Overview

The Smartsheet MCP Server is designed to facilitate intelligent interactions with Smartsheet, providing a robust set of tools for document management, data operations, and column customization. It serves as a critical component in automated workflows, enabling AI systems to programmatically interact with Smartsheet data while maintaining data integrity and enforcing business rules.

Key Benefits

Intelligent Integration: Seamlessly connects AI systems with Smartsheet's collaboration platform
Data Integrity: Enforces validation rules and maintains referential integrity across operations
Formula Management: Preserves and updates formula references automatically
Flexible Configuration: Supports various column types and complex data structures
Error Resilience: Implements comprehensive error handling and validation at multiple layers
Healthcare Analytics: Specialized analysis capabilities for clinical and research data
Batch Processing: Efficient handling of large healthcare datasets
Custom Scoring: Flexible scoring systems for healthcare initiatives and research

Use Cases

1. Clinical Research Analytics

2. Hospital Operations

3. Healthcare Innovation

4. Automated Document Management

5. Data Operations

6. System Integration

Integration Points

The server integrates with:

Smartsheet API for data operations
MCP protocol for standardized communication
Local development tools via stdio interface
Monitoring systems through structured logging

Features

Tools (34 Available)

1. `get_column_map` (Read)

2. `get_sheet_info` (Read - Alias)

3. `smartsheet_write` (Create)

4. `smartsheet_update` (Update)

5. `smartsheet_delete` (Delete)

6. `smartsheet_search` (Search)

7. `smartsheet_add_column` (Column Management)

8. `smartsheet_delete_column` (Column Management)

9. `smartsheet_rename_column` (Column Management)

10. `smartsheet_bulk_update` (Conditional Updates)

11. `get_all_row_ids` (Utility)

12. `start_batch_analysis` (Healthcare Analytics)

13. `get_job_status` (Analysis Monitoring)

14. `cancel_batch_analysis` (Job Control)

15. `list_workspaces` (Workspace Management)

16. `get_workspace` (Workspace Management)

17. `create_workspace` (Workspace Management)

18. `create_sheet_in_workspace` (Workspace Management)

19. `list_workspace_sheets` (Workspace Management)

20. `smartsheet_upload_attachment` (Attachment Management)

21. `smartsheet_get_attachments` (Attachment Management)

22. `smartsheet_download_attachment` (Attachment Management)

23. `smartsheet_delete_attachment` (Attachment Management)

24. `smartsheet_create_discussion` (Discussion Management)

25. `smartsheet_add_comment` (Discussion Management)

26. `smartsheet_get_discussions` (Discussion Management)

27. `smartsheet_get_comments` (Discussion Management)

28. `smartsheet_delete_comment` (Discussion Management)

29. `smartsheet_get_cell_history` (Cell History & Audit)

30. `smartsheet_get_row_history` (Cell History & Audit)

31. `smartsheet_get_sheet_cross_references` (Cross-Sheet References)

32. `smartsheet_find_sheet_references` (Cross-Sheet References)

33. `smartsheet_validate_cross_references` (Cross-Sheet References)

34. `smartsheet_create_cross_reference` (Cross-Sheet References)

Resources (4 Static + 5 Dynamic Templates)

The server provides both static resources and dynamic resource templates for enhanced data access and contextual information.

Static Resources

1. `smartsheet://templates/project-plan` - Project Plan Template

2. `smartsheet://templates/task-tracker` - Task Tracker Template

3. `smartsheet://schemas/column-types` - Column Types Reference

4. `smartsheet://best-practices/formulas` - Formula Best Practices

Dynamic Resource Templates

1. `smartsheet://{sheet_id}/summary` - Sheet Summary

2. `smartsheet://{sheet_id}/gantt-data` - Gantt Chart Data

3. `smartsheet://{workspace_id}/overview` - Workspace Overview

4. `smartsheet://{sheet_id}/dependencies` - Dependency Map

5. `smartsheet://{sheet_id}/health-report` - Sheet Health Report

Prompts (6 Available)

Intelligent prompt templates that provide guided assistance for common Smartsheet operations and analysis.

1. `create_project_plan` - Project Plan Creation Guide

2. `analyze_project_status` - Project Health Analysis

3. `optimize_workflow` - Workflow Optimization

4. `generate_insights` - Data Insights Extraction

5. `create_dashboard_summary` - Executive Dashboard Creation

6. `setup_conditional_formatting` - Conditional Formatting Guide

Key Capabilities

Column Type Management

Data Validation

Search Functionality

Metadata Handling

Healthcare Analytics

Batch Processing

Job Management
- Real-time status monitoring
- Detailed progress tracking
- Error reporting and logging
- Job cancellation support
- Batch operation controls

Cross-Sheet References
- Formula analysis and dependency mapping
- Cross-sheet reference detection and validation
- Broken link identification and repair suggestions
- Automated formula generation (INDEX_MATCH, VLOOKUP, SUMIF, COUNTIF)
- Reference impact analysis across workspaces
- Custom formula template support

Setup

Prerequisites

Node.js and npm
Conda (for environment management)
Smartsheet API access token
Azure OpenAI API access (for batch analysis features)

Environment Setup

1. Create a dedicated conda environment:

bash

conda create -n cline_mcp_env python=3.12 nodejs -y
conda activate cline_mcp_env

2. Install Node.js dependencies:

bash

npm install

3. Install Python dependencies:

bash

cd smartsheet_ops
pip install -e .
cd ..

Note: The Python package includes dependencies for:

`smartsheet-python-sdk` - Smartsheet API client
`python-dotenv` - Environment variable management
`openai` - Azure OpenAI integration
`tiktoken` - Token counting for AI analysis

4. Build the TypeScript server:

bash

npm run build

Configuration

The server supports two transport modes:

STDIO Transport (default): For local development and CLI usage
HTTP Transport: For web-based clients and network access

1. Get Your Smartsheet API Key

1. Log in to Smartsheet

2. Go to Account → Personal Settings → API Access

3. Generate a new access token

2. Configure for STDIO Transport (Cline/Local)

The configuration path depends on your operating system:

macOS:

code

~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Windows:

code

%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json

Linux:

code

~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

json

{
  "mcpServers": {
    "smartsheet": {
      "command": "/Users/[username]/anaconda3/envs/cline_mcp_env/bin/node",
      "args": [
        "/path/to/smartsheet-server/build/index.js",
        "--transport",
        "stdio"
      ],
      "env": {
        "PYTHON_PATH": "/Users/[username]/anaconda3/envs/cline_mcp_env/bin/python3",
        "SMARTSHEET_API_KEY": "your-api-key",
        "AZURE_OPENAI_API_KEY": "your-azure-openai-key",
        "AZURE_OPENAI_API_BASE": "your-azure-openai-endpoint",
        "AZURE_OPENAI_API_VERSION": "your-api-version",
        "AZURE_OPENAI_DEPLOYMENT": "your-deployment-name"
      },
      "disabled": false,
      "autoApprove": [
        "get_column_map",
        "smartsheet_write",
        "smartsheet_update",
        "smartsheet_delete",
        "smartsheet_search",
        "smartsheet_add_column",
        "smartsheet_delete_column",
        "smartsheet_rename_column",
        "smartsheet_bulk_update",
        "start_batch_analysis",
        "get_job_status",
        "cancel_batch_analysis",
        "get_all_row_ids",
        "list_workspaces",
        "get_workspace",
        "create_workspace",
        "create_sheet_in_workspace",
        "list_workspace_sheets"
      ]
    }
  }
}

3. Configure for HTTP Transport

For web-based MCP clients or network access, use the HTTP transport mode:

Start the server:

bash

# Start with default port (3000)
SMARTSHEET_API_KEY=your-api-key PYTHON_PATH=/path/to/python smartsheet-server --transport http

# Start with custom port
SMARTSHEET_API_KEY=your-api-key PYTHON_PATH=/path/to/python smartsheet-server --transport http --port 8080

Client Configuration:

json

{
  "mcpServers": {
    "smartsheet-server": {
      "type": "http",
      "url": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Bearer your-optional-auth-token"
      }
    }
  }
}

Health Check:

The HTTP server provides a health check endpoint:

bash

curl http://localhost:3000/health
# Response: {"status":"ok","server":"smartsheet-mcp"}

Starting the Server

STDIO Transport (Default)

The server will start automatically when Cline or Claude Desktop needs it. However, you can also start it manually for testing.

macOS/Linux:

bash

# Activate the environment
conda activate cline_mcp_env

# Start with STDIO transport (default)
PYTHON_PATH=/Users/[username]/anaconda3/envs/cline_mcp_env/bin/python3 SMARTSHEET_API_KEY=your-api-key node build/index.js

# Or explicitly specify STDIO transport
PYTHON_PATH=/Users/[username]/anaconda3/envs/cline_mcp_env/bin/python3 SMARTSHEET_API_KEY=your-api-key node build/index.js --transport stdio

Windows:

cmd

:: Activate the environment
conda activate cline_mcp_env

:: Start with STDIO transport
set PYTHON_PATH=C:\Users\[username]\anaconda3\envs\cline_mcp_env\python.exe
set SMARTSHEET_API_KEY=your-api-key
node build\index.js --transport stdio

HTTP Transport

For web-based clients or network access:

macOS/Linux:

bash

# Activate the environment
conda activate cline_mcp_env

# Start HTTP server on default port (3000)
PYTHON_PATH=/Users/[username]/anaconda3/envs/cline_mcp_env/bin/python3 SMARTSHEET_API_KEY=your-api-key node build/index.js --transport http

# Start HTTP server on custom port
PYTHON_PATH=/Users/[username]/anaconda3/envs/cline_mcp_env/bin/python3 SMARTSHEET_API_KEY=your-api-key node build/index.js --transport http --port 8080

Windows:

cmd

:: Activate the environment
conda activate cline_mcp_env

:: Start HTTP server
set PYTHON_PATH=C:\Users\[username]\anaconda3\envs\cline_mcp_env\python.exe
set SMARTSHEET_API_KEY=your-api-key
node build\index.js --transport http --port 3000

Command Line Options

bash

# View help
node build/index.js --help

# Available options:
--transport     # "stdio" (default) or "http"
--port        # HTTP port (default: 3000, only used with --transport http)
--help, -h            # Show help message

Verifying Installation

STDIO Transport

1. The server should output "Smartsheet MCP server running on stdio" when started

2. Test the connection using any MCP tool (e.g., get_column_map)

HTTP Transport

1. The server should output "Smartsheet MCP server running on HTTP port 3000" when started

2. Test the health endpoint: `curl http://localhost:3000/health`

3. Expected response: `{"status":"ok","server":"smartsheet-mcp"}`

Python Environment

Check the Python environment has the required packages installed:

bash

conda activate cline_mcp_env
pip show smartsheet-python-sdk openai tiktoken python-dotenv

The Python package should include these key dependencies:

`smartsheet-python-sdk>=2.105.1` - Smartsheet API client
`openai>=1.0.0` - Azure OpenAI integration
`tiktoken>=0.5.0` - Token counting for AI analysis
`python-dotenv>=1.0.0` - Environment variable management

Usage Examples

Getting Column Information (Read)

typescript

// Get column mapping and sample data
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_column_map",
  arguments: {
    sheet_id: "your-sheet-id",
  },
});

Writing Data (Create)

typescript

// Write new rows to Smartsheet
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "smartsheet_write",
  arguments: {
    sheet_id: "your-sheet-id",
    column_map: {
      "Column 1": "1234567890",
      "Column 2": "0987654321",
    },
    row_data: [
      {
        "Column 1": "Value 1",
        "Column 2": "Value 2",
      },
    ],
  },
});

Searching Data

typescript

// Basic text search
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "smartsheet_search",
  arguments: {
    sheet_id: "your-sheet-id",
    pattern: "search text",
    options: {
      case_sensitive: false,
      whole_word: false,
      columns: ["Column1", "Column2"], // Optional: limit search to specific columns
    },
  },
});

// Search PICKLIST column with exact matching
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "smartsheet_search",
  arguments: {
    sheet_id: "your-sheet-id",
    pattern: "In Progress",
    options: {
      columns: ["Status"], // PICKLIST column
      case_sensitive: true,
      whole_word: true,
    },
  },
});

Updating Data (Update)

typescript

// Update existing rows
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "smartsheet_update",
  arguments: {
    sheet_id: "your-sheet-id",
    column_map: {
      Status: "850892021780356",
      Notes: "6861293012340612",
    },
    updates: [
      {
        row_id: "7670198317295492",
        data: {
          Status: "In Progress",
          Notes: "Updated via MCP server",
        },
      },
    ],
  },
});

Deleting Data (Delete)

typescript

// Delete rows from Smartsheet
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "smartsheet_delete",
  arguments: {
    sheet_id: "your-sheet-id",
    row_ids: ["7670198317295492", "7670198317295493"],
  },
});

Healthcare Analytics Examples

typescript

// Example 1: Pediatric Innovation Scoring
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "start_batch_analysis",
  arguments: {
    sheet_id: "your-sheet-id",
    type: "custom",
    sourceColumns: ["Ideas", "Implementation_Details"],
    targetColumn: "Pediatric_Score",
    rowIds: ["row1", "row2", "row3"], // Optional: specify rows, or omit for all rows
    customGoal:
      "Score each innovation 1-100 based on pediatric healthcare impact. Consider: 1) Direct benefit to child patients, 2) Integration with pediatric workflows, 3) Implementation feasibility in children's hospital, 4) Safety considerations for pediatric use. Return only a number.",
  },
});

// Example 2: Clinical Note Summarization
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "start_batch_analysis",
  arguments: {
    sheet_id: "your-sheet-id",
    type: "summarize",
    sourceColumns: ["Clinical_Notes"],
    targetColumn: "Note_Summary",
    rowIds: ["row1", "row2"], // Optional: specify rows, or omit for all rows
  },
});

// Example 3: Patient Satisfaction Analysis
const result = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "start_batch_analysis",
  arguments: {
    sheet_id: "your-sheet-id",
    type: "sentiment",
    sourceColumns: ["Patient_Feedback"],
    targetColumn: "Satisfaction_Score",
    rowIds: ["row1", "row2"], // Optional: specify rows, or omit for all rows
  },
});

// Example 4: Get All Row IDs for Batch Processing
const allRows = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_all_row_ids",
  arguments: {
    sheet_id: "your-sheet-id",
  },
});

// Example 5: Monitor Analysis Job Progress
const jobStatus = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_job_status",
  arguments: {
    sheet_id: "your-sheet-id",
    jobId: "job-uuid-from-start-analysis",
  },
});

Workspace Management Examples

typescript

// List all accessible workspaces
const workspaces = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "list_workspaces",
  arguments: {},
});

// Get details of a specific workspace
const workspace = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_workspace",
  arguments: {
    workspace_id: "6621332407379844",
  },
});

// Create a new workspace
const newWorkspace = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "create_workspace",
  arguments: {
    name: "Project Management",
  },
});

// Create a sheet in a workspace
const newSheet = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "create_sheet_in_workspace",
  arguments: {
    workspace_id: "6621332407379844",
    name: "Task Tracker",
    columns: [
      { title: "Task Name", type: "TEXT_NUMBER" },
      { title: "Due Date", type: "DATE" },
      {
        title: "Status",
        type: "PICKLIST",
        options: ["Not Started", "In Progress", "Completed"],
      },
    ],
  },
});

// List all sheets in a workspace
const sheets = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "list_workspace_sheets",
  arguments: {
    workspace_id: "6621332407379844",
  },
});

Resources Usage Examples

typescript

// Access static resources
const projectTemplate = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://templates/project-plan",
});

const columnTypes = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://schemas/column-types",
});

const formulaGuide = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://best-practices/formulas",
});

// Access dynamic resources
const sheetSummary = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://8596778555232132/summary",
});

const ganttData = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://8596778555232132/gantt-data",
});

const workspaceOverview = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://6621332407379844/overview",
});

const dependencyMap = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://8596778555232132/dependencies",
});

const healthReport = await access_mcp_resource({
  server_name: "smartsheet",
  uri: "smartsheet://8596778555232132/health-report",
});

Prompts Usage Examples

typescript

// Project plan creation guidance
const projectPlanPrompt = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_prompt",
  arguments: {
    name: "create_project_plan",
    arguments: {
      project_name: "Website Redesign",
      project_type: "software",
      duration_estimate: "3 months",
    },
  },
});

// Project health analysis
const analysisPrompt = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_prompt",
  arguments: {
    name: "analyze_project_status",
    arguments: {
      sheet_id: "8596778555232132",
      focus_area: "timeline",
    },
  },
});

// Workflow optimization suggestions
const optimizationPrompt = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_prompt",
  arguments: {
    name: "optimize_workflow",
    arguments: {
      sheet_id: "8596778555232132",
      workflow_type: "approval",
    },
  },
});

// Data insights extraction
const insightsPrompt = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_prompt",
  arguments: {
    name: "generate_insights",
    arguments: {
      sheet_id: "8596778555232132",
      insight_type: "bottlenecks",
    },
  },
});

// Executive dashboard creation
const dashboardPrompt = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_prompt",
  arguments: {
    name: "create_dashboard_summary",
    arguments: {
      workspace_id: "6621332407379844",
      summary_focus: "risks",
    },
  },
});

// Conditional formatting setup
const formattingPrompt = await use_mcp_tool({
  server_name: "smartsheet",
  tool_name: "get_prompt",
  arguments: {
    name: "setup_conditional_formatting",
    arguments: {
      sheet_id: "8596778555232132",
      formatting_goal: "status indicators",
    },
  },
});

Development

For development with auto-rebuild:

bash

npm run watch

CI/CD Pipeline

This project implements a comprehensive 8-stage CI/CD pipeline with GitHub Actions, ensuring code quality, security, and reliability across all components.

Pipeline Architecture

The CI/CD pipeline consists of 8 coordinated jobs that run in parallel and sequence for optimal efficiency:

1. TypeScript Quality Checks - ESLint, type checking, formatting validation

2. Python Quality Checks - Black, Flake8, MyPy type checking

3. TypeScript Testing - Matrix testing on Node.js 16, 18, 20 with coverage

4. Python Testing - Matrix testing on Python 3.8, 3.9, 3.10, 3.11 with coverage

5. Combined Coverage - Unified coverage reporting and Codecov integration

6. Integration Testing - End-to-end validation and MCP server startup verification

7. Security Scanning - npm audit, Python safety, Bandit security analysis

8. Build and Package - Artifact creation and deployment verification

Key Pipeline Features

Quality Assurance:

Multi-language Support: Full TypeScript and Python pipeline coverage
Matrix Testing: Cross-platform compatibility verification
Code Quality Gates: ESLint, Black, Flake8, MyPy, TypeScript strict mode
Coverage Enforcement: Automated coverage threshold validation
Security Scanning: Regular vulnerability assessment with safety and Bandit

Performance Optimization:

Parallel Execution: Independent jobs run concurrently for faster feedback
Intelligent Caching: Node modules and Python dependencies cached across runs
Conditional Execution: Performance tests only on PRs, full coverage on main
Artifact Management: Build artifacts preserved for 7-30 days

Integration and Deployment:

MCP Protocol Validation: Server startup and protocol compliance testing
Docker Support: Multi-platform container builds (linux/amd64, linux/arm64)
Automated Releases: Version-tagged releases with changelog generation
Dependency Management: Weekly security audits and update automation

Workflow Triggers

yaml

# Comprehensive testing on main branches
- push: [main, develop]
- pull_request: [main, develop]

# Additional workflows
- release: version tags (v*.*.*)
- security: weekly dependency scans
- performance: PR-specific testing

Status Monitoring

The pipeline provides comprehensive notifications and artifact management, ensuring all stakeholders have visibility into build status, test results, and deployment readiness.

Testing and Quality Assurance

This project maintains comprehensive test coverage and quality assurance across both TypeScript and Python components with automated CI/CD pipelines.

Test Infrastructure

Test Status: 54/54 TypeScript tests passing, 5/5 Python tests passing

Our comprehensive testing strategy includes:

Unit Tests: Jest for TypeScript (54 tests), pytest for Python (5 core tests)
Integration Tests: Cross-component testing and MCP protocol validation
Code Quality: ESLint, TypeScript checking, Black, Flake8, MyPy
Security Scanning: npm audit, Python safety checks, Bandit analysis
Coverage Analysis: Combined coverage reporting with Codecov integration
Performance Testing: Startup time measurement and benchmark tracking

Test Coverage Overview

Current coverage metrics:

TypeScript Coverage: Comprehensive coverage of MCP server implementation
Python Coverage: Core operations and CLI functionality
Combined Reporting: Unified coverage analysis across both languages
Automated Tracking: Real-time coverage monitoring via Codecov

Quick Testing Commands

bash

# Essential testing commands for daily development
npm run ci:check          # Pre-commit validation (recommended before push)
npm run test:all          # Run all tests with coverage
npm run coverage          # Full coverage analysis with combined reporting
npm run coverage:open     # View coverage reports in browser

# Individual test suites
npm test                  # TypeScript tests only
npm run test:python       # Python tests only
npm run test:coverage     # TypeScript with coverage
npm run test:python:coverage  # Python with coverage

# Development testing
npm run test:watch        # Watch mode for continuous testing
npm run coverage:clean    # Coverage without external uploads

Comprehensive Testing Commands

bash

# Quality assurance
npm run lint              # ESLint for TypeScript
npm run lint:fix          # Auto-fix linting issues
npm run format            # Prettier code formatting
npm run typecheck         # TypeScript type validation

# Coverage and reporting  
npm run badges:update     # Generate coverage badges
npm run coverage:ci       # CI-optimized coverage reporting
npm run coverage:view     # Open all coverage reports
npm run coverage:combined # View combined coverage report

# Build and validation
npm run build             # Build TypeScript
npm run watch             # Development build with watch
npm run inspector         # MCP inspector for tool testing

Test Reports and Artifacts

After running tests, detailed reports are available:

TypeScript Coverage: `./coverage/index.html`
Python Coverage: `./smartsheet_ops/coverage/index.html`
Combined Coverage: `./coverage-combined/index.html`
Test Artifacts: Available in CI/CD pipeline runs

Quality Thresholds

The project enforces strict quality standards:

TypeScript Coverage: 60% minimum (configurable per component)
Python Coverage: 80% overall with line-by-line reporting
Code Quality: ESLint rules, TypeScript strict mode, Python Black/Flake8
Security: Regular dependency audits and vulnerability scanning
Performance: Startup time monitoring and regression detection

Docker Support

Build and run the containerized version:

bash

# Build Docker image
docker build -t smartsheet-server .

# Run with environment variables
docker run -e SMARTSHEET_API_KEY=your_key -e PYTHON_PATH=/usr/local/bin/python smartsheet-server

Debugging

Since MCP servers communicate over stdio, debugging can be challenging. The server implements comprehensive error logging and provides detailed error messages through the MCP protocol.

Key debugging features:

Error logging to stderr
Detailed error messages in MCP responses
Type validation at multiple levels
Comprehensive operation result reporting
Dependency analysis for column operations
Formula reference tracking

Error Handling

The server implements a multi-layer error handling approach:

1. MCP Layer

2. CLI Layer

3. Operations Layer

Contributing

Contributions are welcome! Please ensure:

1. TypeScript/Python code follows existing style

2. New features include appropriate error handling

3. Changes maintain backward compatibility

4. Updates include appropriate documentation

5. Column operations maintain data integrity

6. Formula references are properly handled

Frequently asked questions

What is smartsheet-server?

smartsheet-server is MCP server providing healthcare analytics capabilities for Smartsheet, including clinical note summarization, patient feedback analysis, and research impact assessment

How do I install smartsheet-server?

Open the GitHub repository and follow its README. Most MCP servers are added to your client's MCP config, then called by your agent.

Is smartsheet-server open source?

Yes — it is hosted on GitHub at https://github.com/terilios/smartsheet-server and has 12 stars.

Related MCP tools

semble

Fast and Accurate Code Search for Agents. Uses 99% fewer tokens than grep+read

5,993 Python

agentscode-searchembeddings+4

FinanceToolkit

Transparent and Efficient Financial Analysis

5,288 Python

financial-statementsstock-datafundamental-analysis+17

tradingview-mcp

TradingView MCP server — real-time market data, technical analysis, screeners & backtesting for Claude, ChatGPT, Cursor & any MCP client. Stocks, crypto, forex & futures across global exchanges. Hosted or self-host.

4,351 Python

claude-desktopcryptocurrencymcp-server+10

openshorts

Open source AI clip generator: turns long videos into viral 9:16 shorts with AI moment detection, face tracking, subtitles and dubbing. Self-host free with Docker (MIT), or use the cloud with GPU speed from $12/mo. MCP server and API for AI agents.

3,851 Python

clip-generatoropen-sourceshorts+10

google_workspace_mcp

Control Gmail, Google Calendar, Docs, Sheets, Slides, Chat, Forms, Tasks, Search & Drive with AI - Comprehensive Google Workspace MCP Server & CLI Tool

3,117 Python

aigmailgoogle-calendar+17

jcodemunch-mcp

Cut AI token costs 95%+ on code exploration. The leading MCP server for precise, symbol-level GitHub code retrieval via tree-sitter AST. Works with Claude Code, Cursor & any MCP client. 313B+ tokens saved.

2,651 Python

claudeclaude-codeai-coding+17

Run your own MCP server? See who uses it and what to fix.

Measure it with TrackMCP