WeWork MCP Server
Manages configuration settings and API access tokens through environment variables stored in .env files for secure credential management.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@WeWork MCP Serveranalyze tasks for the marketing campaign project"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
WeWork MCP Server
A Model Context Protocol (MCP) server that provides access to WeWork project management data through Claude and other LLM clients. This server exposes WeWork project information, task analysis, and project management tools.
Features
🔍 Project Search
Search projects by name with fuzzy matching
Find best matching projects using cosine similarity
Get list of all available projects
📊 Project Analysis
Detailed task analysis within projects
Completion progress statistics
Task categorization by status and assignee
Export data to CSV files
📋 Information Management
Get detailed project information
Track deadlines and completion dates
Analyze task failure reasons
Related MCP server: ClickUp MCP Integration
Prerequisites
Python 3.12+
WeWork API access token
uv package manager
Installation
Clone this repository:
git clone <repository-url>
cd wework-mcp-serverInstall dependencies:
uv syncConfiguration
Local Setup
1. WeWork Access Token
Option A: Environment Variable (Recommended)
Create a .env file in the project root:
WEWORK_ACCESS_TOKEN=your_actual_wework_token_hereOption B: Direct Configuration
Update the WEWORK_ACCESS_TOKEN in wework_mcp_server.py with your actual WeWork API token.
2. Claude Desktop Configuration (Local)
Add this server to your Claude Desktop configuration file:
Windows: %APPDATA%/Claude/claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/claude/claude_desktop_config.json
{
"mcpServers": {
"WeWork Task Analysis Server": {
"command": "uv",
"args": [
"--directory",
"/path/to/wework-mcp-server",
"run",
"wework_mcp_server.py"
]
}
}
}3. Restart Claude Desktop
After adding the configuration, restart Claude Desktop to apply changes.
Remote Deployment 🚀
Deploy the server to cloud platforms for remote access by Claude.
Quick Deploy với Railway (Khuyến nghị)
# Install Railway CLI
npm install -g @railway/cli
# Deploy
chmod +x deploy_scripts.sh
./deploy_scripts.sh
# Choose option 1 (Railway)Deploy Options
Railway:
./deploy_scripts.sh→ option 1Docker:
docker-compose up --buildHeroku:
./deploy_scripts.sh→ option 4Manual: Xem
DEPLOY_GUIDE.md
Remote Claude Configuration
Sau khi deploy, cập nhật Claude config:
{
"mcpServers": {
"wework-remote": {
"command": "curl",
"args": ["-X", "GET", "https://your-app.railway.app/api/test"]
}
}
}📖 Chi tiết: Xem DEPLOY_GUIDE.md cho hướng dẫn deploy đầy đủ.
Usage
Example Prompts
"Show me all available projects"
"Find project 'marketing campaign'"
"Analyze tasks for project ID 12345"
"Get statistics for the development project"
"Export task analysis to CSV"
Available Resources
file://projects/available- List all available WeWork projects
Available Tools
MCP Tools (Local)
search_projects- Search for projects by namefind_project_by_name- Find project with similarity matchingget_project_details- Get detailed information about a specific projectanalyze_project_tasks- Analyze tasks within a projectget_project_statistics- Get comprehensive project statistics
HTTP Endpoints (Remote)
GET /health- Health checkGET /api/test- Test WeWork connectionGET /api/projects?search=<text>- Search projectsPOST /api/project/details- Get project detailsPOST /api/project/analyze- Analyze project tasks
Development
Run Server for Testing
# Using uv
uv run wework_mcp_server.py
# Or with Python
python wework_mcp_server.py
# Run tests
python test_wework_server.pyData Structure
Task Analysis DataFrame Columns
Column | Description |
| Task category |
| Task name |
| Subtask (if any) |
| Assignee |
| Related people |
| Task description |
| Status (Completed/In Progress/Failed) |
| Achievement results |
| Failure reason |
| Start date |
| Due date |
| Completion date |
Troubleshooting
Common Issues
Access token expired: Update token in
.envfile orwework_mcp_server.pyDependencies not found: Run
uv syncto install all dependenciesClaude Desktop doesn't recognize server: Check file paths in config and restart Claude Desktop
CSV encoding issues: Files are exported with UTF-8-BOM encoding
Debug Mode
python wework_mcp_server.py --debugSecurity Notes
⚠️ Important: For production use:
Always use environment variables (
.envfile) instead of hardcoding tokensAdd
.envto your.gitignoreto prevent committing sensitive dataDo not commit access tokens to git repository
Use only in trusted environments
Regularly rotate your access tokens
License
This project is licensed under the MIT License.
Acknowledgments
WeWork for providing the project management platform and API
Model Context Protocol team for the MCP framework
Available Tools
6 toolsanalyze_project_tasksC
Phân tích các tasks trong dự án
Args:
project_id: ID của dự án
export_csv: Có xuất file CSV không (default: False)
Returns:
Phân tích tasks dưới dạng dictionary
| Name | Required | Description | Default |
|---|---|---|---|
| project_id | Yes | ||
| export_csv | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool can export a CSV file, which implies a file generation or download behavior, but doesn't specify where the CSV is saved, if it's returned as data, or any permissions/rate limits. This leaves significant gaps for a tool with potential side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and structured with clear sections for Args and Returns, making it easy to scan. However, the first sentence 'Phân tích các tasks trong dự án' is somewhat redundant with the tool name and could be more specific to add value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an analysis tool with 2 parameters, no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose and parameters but lacks details on the analysis output format (beyond 'dictionary'), error handling, or integration with sibling tools, leaving room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context beyond the input schema, which has 0% description coverage. It explains that 'project_id' is the ID of the project and 'export_csv' controls whether to export a CSV file with a default of False. This clarifies the purpose of each parameter, compensating for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool 'analyzes tasks in a project' which provides a basic purpose, but it's vague about what specific analysis is performed (e.g., metrics, trends, completion rates). It doesn't clearly distinguish from siblings like 'get_project_statistics' which might overlap in functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_project_statistics' or 'get_project_details'. The description lacks context about prerequisites, such as needing an existing project, and doesn't mention when not to use it (e.g., for simple task listing vs. analysis).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_project_by_nameB
Tìm dự án theo tên với độ tương đồng
Args:
project_name: Tên dự án cần tìm
threshold: Ngưỡng tương đồng tối thiểu (default: 0.3)
Returns:
Thông tin dự án phù hợp nhất
| Name | Required | Description | Default |
|---|---|---|---|
| project_name | Yes | ||
| threshold | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the similarity matching mechanism and default threshold, which is useful. However, it doesn't describe critical behaviors: whether this is a read-only operation, what happens if no matches are found, how similarity is calculated, performance characteristics, or error conditions. For a search tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise and well-structured. It begins with a clear purpose statement, then uses labeled sections (Args, Returns) to organize parameter and return value information. Each sentence earns its place by providing essential information without redundancy. The bilingual presentation (Vietnamese/English) is efficient for parameter documentation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (similarity-based search), no annotations, no output schema, and 2 parameters, the description is minimally adequate but has clear gaps. It covers the basic purpose and parameters well, but lacks information about return format, error handling, similarity algorithm details, and comparison with sibling tools. The absence of an output schema means the description should ideally explain what 'Thông tin dự án phù hợp nhất' (most suitable project information) contains, which it doesn't.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful semantic context for both parameters beyond what the schema provides. For 'project_name', it explains this is 'Tên dự án cần tìm' (name of project to find). For 'threshold', it provides crucial context: 'Ngưỡng tương đồng tối thiểu' (minimum similarity threshold) with a default value. Given the schema has 0% description coverage, the description compensates well by explaining what each parameter means in the context of similarity matching.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Tìm dự án theo tên với độ tương đồng' (Find project by name with similarity). This specifies the verb (find), resource (project), and key mechanism (similarity matching). It distinguishes from siblings like 'get_project_details' (which likely retrieves specific project data) and 'search_projects' (which may have broader search capabilities), though the differentiation isn't explicitly stated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'search_projects' or 'get_project_details', nor does it specify prerequisites or exclusions. The only implied usage is for finding projects by name with similarity matching, but this is essentially restating the purpose rather than providing contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_project_detailsB
Lấy chi tiết của một dự án
Args:
project_id: ID của dự án
Returns:
Chi tiết dự án bao gồm thông tin cơ bản
| Name | Required | Description | Default |
|---|---|---|---|
| project_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this retrieves project details including basic information, which implies a read-only operation, but doesn't specify whether authentication is required, rate limits exist, what happens if the project_id doesn't exist, or the format of returned data. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured with clear sections for Args and Returns. Each sentence earns its place: the purpose statement, parameter explanation, and return value description. No wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simple nature (single parameter, no output schema, no annotations), the description is minimally adequate. It explains what the tool does and documents the parameter, but doesn't provide enough context about behavioral aspects like error conditions, authentication requirements, or data format. For a basic read operation, this is the minimum viable description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explicitly documents the single parameter 'project_id' with its purpose ('ID của dự án' - ID of the project), adding meaningful context beyond the schema which has 0% description coverage. Since there's only one parameter and the description fully explains it, this compensates well for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Lấy chi tiết của một dự án' (Get details of a project), which is a specific verb+resource combination. It distinguishes from siblings like 'analyze_project_tasks' or 'get_project_statistics' by focusing on basic project details rather than analysis or statistics. However, it doesn't explicitly differentiate from 'find_project_by_name' which might also retrieve project details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'find_project_by_name' (which might search by name instead of ID) or 'search_projects' (which might return multiple projects). There are no explicit when/when-not instructions or prerequisites for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_project_statisticsC
Lấy thống kê tổng quan về dự án
Args:
project_id: ID của dự án
Returns:
Thống kê chi tiết về dự án
| Name | Required | Description | Default |
|---|---|---|---|
| project_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a statistics retrieval operation but doesn't mention whether it's read-only, requires specific permissions, has rate limits, or what format the statistics are returned in. The description is too minimal for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with a clear purpose statement followed by Args and Returns sections. However, the Returns section 'Thống kê chi tiết về dự án' (Detailed statistics about the project) is somewhat redundant with the purpose statement and could be more specific.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations, no output schema, and minimal behavioral disclosure, the description is incomplete. It doesn't explain what kind of statistics are returned, how they're formatted, or any behavioral characteristics. The description should provide more context given the lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description includes an 'Args' section that explains the single parameter 'project_id' as 'ID của dự án' (ID of the project). With only 1 parameter and 0% schema description coverage, this minimal explanation is sufficient to understand the parameter's purpose, earning a baseline 4 for single-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Lấy thống kê tổng quan về dự án' (Get overview statistics about the project), which provides a basic verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'get_project_details' or 'analyze_project_tasks', leaving ambiguity about what specific statistics are provided versus other project-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives like 'get_project_details' or 'analyze_project_tasks'. The description only states what the tool does, not when it's appropriate or what distinguishes it from similar tools in the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_projectsB
Tìm kiếm dự án theo tên
Args:
search_text: Text để tìm kiếm trong tên dự án
limit: Số lượng kết quả tối đa (default: 10)
Returns:
Danh sách các dự án phù hợp
| Name | Required | Description | Default |
|---|---|---|---|
| search_text | Yes | ||
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While it mentions the tool returns a list of matching projects, it doesn't describe important behavioral aspects like whether this is a read-only operation, how results are sorted, what happens with empty searches, or any rate limits. For a search tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately concise. It uses clear sections (Args, Returns) with bullet-like formatting, presents essential information upfront, and avoids unnecessary elaboration. Every sentence serves a purpose, though the formatting could be slightly more polished.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and parameters but lacks important context about behavioral traits, usage guidelines relative to siblings, and output format details. The absence of an output schema means the description should ideally explain more about what 'Danh sách các dự án phù hợp' (List of matching projects) contains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful semantic context for both parameters beyond what the input schema provides. The schema has 0% description coverage, but the description explains that 'search_text' is 'Text để tìm kiếm trong tên dự án' (Text to search within project names) and 'limit' is 'Số lượng kết quả tối đa' (Maximum number of results) with a default value. This compensates well for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Tìm kiếm dự án theo tên' (Search projects by name). This is a specific verb+resource combination that indicates searching projects using name-based criteria. However, it doesn't explicitly differentiate from sibling tools like 'find_project_by_name' or 'analyze_project_tasks,' which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'find_project_by_name' and 'analyze_project_tasks' available, there's no indication of when this search tool is preferred, what its limitations are, or any prerequisites for use. This leaves the agent without contextual usage information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
test_connectionB
Test kết nối với WeWork API
Returns:
Thông tin về trạng thái kết nối
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool tests a connection and returns connection status information, which covers basic behavior. However, it lacks details on what 'testing' entails (e.g., authentication checks, network pings), potential side effects, error handling, or rate limits. For a tool with zero annotation coverage, this is a significant gap in behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the first sentence states the purpose clearly, and the second sentence describes the return value. There's no wasted text, and both sentences earn their place by providing essential information. It could be slightly improved by integrating the return info more seamlessly, but it's efficiently structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally complete. It explains what the tool does and what it returns, which is adequate for a simple diagnostic tool. However, without annotations or output schema, it could benefit from more detail on the return format (e.g., what 'connection status' includes) or error cases, leaving some contextual gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100% (though empty). The description doesn't need to add parameter semantics, as there are none to explain. This meets the baseline for tools with no parameters, as the description appropriately focuses on the tool's action and output without unnecessary parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Test kết nối với WeWork API' (Test connection to WeWork API). It specifies the verb ('test') and resource ('connection to WeWork API'), making the action explicit. However, it doesn't differentiate from sibling tools, which are all project-related, so this distinction is inherent but not explicitly stated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for testing connections, or how it relates to the sibling project tools. Usage is implied only by the purpose, with no explicit when/when-not instructions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
- First observed
analyze_project_tasks - First observed
find_project_by_name - First observed
get_project_details - First observed
get_project_statistics - First observed
search_projects - First observed
test_connection
TDQS
Most tools have distinct purposes: analyze_project_tasks focuses on task analysis, find_project_by_name and search_projects handle project discovery (though these two could be confused), get_project_details and get_project_statistics provide different project information, and test_connection is clearly separate. The main ambiguity is between find_project_by_name and search_projects, which both search projects by name with slightly different approaches.
Tool names follow a consistent snake_case pattern with clear verb_noun structure (analyze_project_tasks, find_project_by_name, get_project_details, etc.). The only minor deviation is test_connection, which uses a simpler verb_noun pattern but still fits the overall naming convention.
With 6 tools, this is well-scoped for a project management server focused on WeWork. The count is appropriate as it covers core operations (project discovery, details, statistics, task analysis) without being overwhelming or too sparse for the domain.
The toolset covers project discovery and analysis well but has notable gaps in project lifecycle management. There are no tools for creating, updating, or deleting projects or tasks, which limits agents to read-only operations. However, for analysis and monitoring purposes, the existing tools provide reasonable coverage.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
A Model Context Protocol server for Wix AI tools
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Model Context Protocol server for todo.vu task management and time tracking.
Model Context Protocol server for Studex tools, notifications, and profile integrations
Related MCP Servers
-licenseNot gradedqualityNot gradedmaintenanceA Model Context Protocol server that enables Claude Desktop users to interact directly with PostHog, allowing them to view projects and create annotations through natural language commands.10-- AlicenseBqualityDmaintenanceA Model Context Protocol server that enables Large Language Models to interact with ClickUp workspace tasks and data, allowing creation and retrieval of tasks through natural language.192526MIT
- AlicenseBqualityFmaintenanceA Model Context Protocol server that enables AI assistants to interact with Feishu project management systems, allowing retrieval of project views and work items.612MIT
- AlicenseNot gradedqualityDmaintenanceA Model Context Protocol server providing comprehensive task management capabilities with support for project organization, task tracking, and automatic PRD parsing into actionable items.37MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/FOX2920/Aplus-MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server