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., "@upsprint-mcp generate SDD for task 101"
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.
Servidor MCP para a API Upsprints. Permite que qualquer modelo de IA compatível com MCP (Claude, Cursor, modelos locais via Ollama/LM Studio + clientes MCP, etc.) acesse o usuário, companies, projetos e tarefas — e gere SDDs (Software Design Documents) a partir das tarefas.
Funciona por stdio, então roda local e não expõe porta nenhuma.
Há dois modos, que podem ser usados juntos ou separados:
Escrita via Webhook (UPSPRINT_WEBHOOK_TOKEN): usa POST /webhooks/upsprint com header x-upsprint-token. Habilita as tools create_task, update_task, move_task, move_task_and_update e assign_task — exatamente as 5 ações permitidas do token.
Leitura via API JWT (UPSPRINT_API_URL + UPSPRINT_EMAIL + UPSPRINT_PASSWORD): login em 2 etapas (/auth/login → /auth/select-company), JWT em memória com refresh automático. Habilita as tools de leitura (get_me, list_my_tasks, get_task, generate_sdd_context, etc.). Usuários MASTER trocam de company com select_company.
Se só o webhook estiver configurado, o servidor sobe apenas com as tools de escrita.
Related MCP server: EverHour MCP Server
cd upsprint-mcp
npm install
npm run buildVariáveis de ambiente (veja .env.example):
Variável | Modo | Descrição |
| escrita | Token |
| escrita | Endpoint do webhook (default |
| leitura | URL base da API (ex.: |
| leitura | E-mail do usuário |
| leitura | Senha do usuário |
| leitura (opcional) | Company selecionada automaticamente no login |
Pelo menos um dos dois modos precisa estar configurado.
Em claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"upsprint": {
"command": "node",
"args": ["/caminho/para/Upsprints/upsprint-mcp/dist/index.js"],
"env": {
"UPSPRINT_WEBHOOK_TOKEN": "ups_seu_token_aqui",
"UPSPRINT_API_URL": "http://localhost:9002",
"UPSPRINT_EMAIL": "seu-email@exemplo.com",
"UPSPRINT_PASSWORD": "sua-senha"
}
}
}
}claude mcp add upsprint \
-e UPSPRINT_API_URL=http://localhost:9002 \
-e UPSPRINT_EMAIL=seu-email@exemplo.com \
-e UPSPRINT_PASSWORD=sua-senha \
-- node /caminho/para/Upsprints/upsprint-mcp/dist/index.jsMesmo formato JSON em .cursor/mcp.json (ou equivalente do cliente):
{
"mcpServers": {
"upsprint": {
"command": "node",
"args": ["/caminho/para/Upsprints/upsprint-mcp/dist/index.js"],
"env": {
"UPSPRINT_API_URL": "http://localhost:9002",
"UPSPRINT_EMAIL": "seu-email@exemplo.com",
"UPSPRINT_PASSWORD": "sua-senha"
}
}
}
}Qualquer cliente que implemente MCP por stdio funciona — basta apontar command/args/env como acima. Exemplos: LM Studio (mcp.json nas configurações), oterm para Ollama, ou um agente próprio com o SDK MCP.
UPSPRINT_API_URL=http://localhost:9002 \
UPSPRINT_EMAIL=... UPSPRINT_PASSWORD=... \
npm run inspectAbre o MCP Inspector no navegador para chamar as tools manualmente.
UPSPRINT_WEBHOOK_TOKEN)Tool | Ação webhook | Descrição |
|
| Cria task em um projeto (suporta |
|
| Atualiza campos ( |
|
| Move para outra coluna ( |
|
| Move e atualiza campos em uma operação |
|
| Atribui a task a um usuário ( |
Enums: prioridade VERY_LOW | LOW | MEDIUM | HIGH | URGENT; status TODO | DOING | IN_PROGRESS | REVIEW | DONE | BLOCKED.
Tool | Descrição |
| Perfil do usuário autenticado (role, company ativa) |
| Companies do usuário; com |
| Troca a company ativa do token |
| Tarefas atribuídas ao usuário na company ativa |
| Projetos da company ativa |
| Tarefas de um projeto (filtros: busca, responsável, coluna, prioridade) |
| Detalhes completos de uma tarefa (subtarefas, checklists, sprint, release) |
| Histórico de atividades de uma tarefa |
| Monta o contexto completo da tarefa + template de SDD para o modelo escrever |
Também há o prompt create-sdd (aparece como comando no cliente MCP), que executa o fluxo completo de geração de SDD para uma tarefa.
get_me — confirma usuário e role.
(MASTER) list_companies com all: true → select_company na company desejada.
list_my_tasks — vê as tarefas pendentes.
Para cada tarefa que vira feature: generate_sdd_context → o modelo escreve o SDD-<feature>.md.
(Opcional) update_task para anexar o SDD na descrição da tarefa, e move_task para movê-la no board.
Exemplo de pedido ao modelo:
"Liste minhas tarefas na Upsprints e gere um SDD para a tarefa X do projeto Y, salvando como SDD-x.md."
As credenciais ficam só na configuração local do cliente MCP; nada é gravado em disco pelo servidor.
O token JWT vive em memória e é renovado automaticamente.
Prefira um usuário dedicado/da conta com o menor privilégio necessário; use MASTER apenas se precisar atravessar companies.
npm run dev # roda com tsx (sem build)
npm run build # compila para dist/Estrutura:
upsprint-mcp/
├── src/
│ ├── index.ts # servidor MCP e definição das tools
│ ├── api-client.ts # cliente HTTP + autenticação automática
│ └── sdd.ts # montagem do contexto e template do SDD
├── .env.example
└── README.mdAtribui uma task a um usuário específico (action assignTask).
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | UUID da task | |
| user_id | Yes | UUID do usuário |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It only states the basic action without disclosing behavioral traits like idempotency, side effects, authorization needs, or what happens to previous assignments. The behavioral information 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 a single sentence, which is concise and contains the essential verb-resource pairing. It could be slightly expanded to add context without losing conciseness.
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 simple two-parameter tool, the description is minimally sufficient but lacks details about the effect of assignment (e.g., overwriting) and any constraints. It does not leverage the opportunity to provide complete context.
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?
Schema description coverage is 100%, with each parameter described as UUID. The description adds no additional meaning beyond the schema, so baseline 3 is appropriate.
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 action: assigns a task to a specific user. It includes the action name in parentheses for clarity. While it distinguishes from sibling tools (create, update, move), it does not explicitly contrast them, but the purpose is unambiguous.
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 vs alternatives. The description does not mention prerequisites, such as whether the task must exist or if the user must be valid, nor does it indicate if this assignment replaces prior assignments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Cria uma nova task em um projeto via webhook (action createTask). Suporta campos personalizados de formulário via metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| title | Yes | Título da task | |
| value | No | ||
| column | No | Nome ou ID da coluna inicial | |
| form_id | No | ||
| user_id | No | UUID do responsável | |
| due_date | No | Data de entrega (ISO 8601) | |
| metadata | No | Campos personalizados (form binding) | |
| priority | No | Prioridade da task | |
| project_id | Yes | UUID do projeto | |
| client_name | No | ||
| description | No | Descrição (pode conter o SDD em Markdown) | |
| client_phone | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only states the tool creates a task via webhook, but does not reveal any side effects, required permissions, rate limits, or what happens after creation. This is insufficient for a mutation operation.
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: two short sentences that convey the core functionality and a key feature. No unnecessary words or repetition. It earns its place.
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 complexity (12 parameters, no output schema, no annotations), the description is far from complete. It fails to explain return values, error handling, permission requirements, or how the webhook integration works. A create operation with many parameters demands more context.
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?
Schema description coverage is 67%, which is moderate. The description highlights 'metadata' for custom fields but does not elaborate on other parameters like format or constraints. The schema itself provides basic descriptions for most parameters, but the description adds minimal value beyond that.
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 action ('Cria uma nova task'), resource ('task'), and context ('em um projeto via webhook'). It also mentions a specific feature (custom fields via metadata). The sibling tools (update, move) are distinct, so this tool's purpose is unambiguous.
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 siblings. It does not mention any prerequisites, limitations, or alternative tools. The agent is left to infer solely from the tool's name and purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Move uma task para outra coluna do board (action moveTask). A coluna atual é detectada automaticamente.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | UUID da task | |
| position | No | Posição na coluna | |
| to_column_id | Yes | UUID da coluna de destino |
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 adds that the current column is detected automatically, which is useful, but does not disclose permissions, side effects, or potential errors. The description is minimal for a mutation tool.
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 consists of two short sentences that directly convey the tool's purpose and key behavior. No wasted words, and the core action is front-loaded.
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 simple move operation with 3 parameters, the description covers the main functionality but lacks information about return values, error handling, or any side effects. Adequate but not thorough.
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?
Schema description coverage is 100%, so the schema already documents each parameter. The description adds context by explaining the absence of a 'from_column' parameter due to automatic detection, which adds value. Scores baseline 3.
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 moves a task to another column and mentions the action name 'moveTask'. It is specific about the resource and action, but does not explicitly differentiate from sibling tools like 'move_task_and_update', so a slight deduction.
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 like 'move_task_and_update' or 'assign_task'. It neither states prerequisites nor exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Move uma task para outra coluna e atualiza campos na mesma operação (action moveTaskAndUpdate).
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | Novo título | |
| value | No | Valor da task | |
| status | No | Status da task | |
| form_id | No | ID do formulário vinculado à coluna | |
| task_id | Yes | UUID da task | |
| user_id | No | UUID do usuário responsável | |
| due_date | No | Data de entrega (ISO 8601, ex.: 2026-06-30) | |
| metadata | No | Campos personalizados do formulário (chave = name do field) | |
| position | No | ||
| priority | No | Prioridade da task | |
| client_name | No | ||
| description | No | Nova descrição (use para gravar o SDD na task) | |
| client_phone | No | ||
| to_column_id | Yes | UUID da coluna de destino |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It only states the basic action without detailing transactional atomicity, permission requirements, side effects, or error handling. The 'webhook' in the title is not explained.
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 a single concise sentence that front-loads the purpose. No redundant or extra 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 complexity (14 params, composite action, no output schema, no annotations), the description is insufficient. It omits return value, error conditions, constraints, and important context like webhook behavior or column existence requirements.
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?
Schema description coverage is high (79%), so baseline is 3. The description adds no extra meaning beyond the schema. It does not elaborate on any parameter purpose or format.
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 verb 'Move' and 'atualiza' (update) on the resource 'task', specifying moving to another column and updating fields in one operation. It effectively distinguishes from sibling tools like move_task and update_task.
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 composite tool versus its siblings (move_task, update_task, etc.). It does not mention conditions, exclusions, or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Atualiza campos de uma task existente sem movê-la (action updateTask). Pelo menos um campo em "updates" é obrigatório. Útil para anexar o SDD gerado na descrição.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | UUID da task | |
| updates | Yes | Campos a atualizar (pelo menos um) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool does not move the task (implying no positional change). However, it omits details on authentication needs, side effects (e.g., audit logs), idempotency, error handling, or response format.
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?
Two concise, front-loaded sentences. Every word earns its place: action name, critical constraint ('sem movê-la'), required element ('pelo menos um campo'), and a practical use case. No filler or redundancy.
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 lack of output schema and annotations, the description could be more comprehensive. It doesn't explain return values, error conditions (e.g., what happens if updates object is empty), or rate limits. It compensates partially with the SDD use case but leaves gaps in behavioral context.
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?
Schema coverage is 100% (both parameters documented), so baseline is 3. The description adds value by clarifying that at least one sub-field in 'updates' is mandatory (not enforced by schema) and by providing a concrete example for the 'description' field (SDD attachment). This helps the agent understand parameter constraints beyond schema.
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 it updates existing tasks without moving them, distinguishing it from sibling move tools. It also specifies the action name 'updateTask' and a common use case (attaching generated SDD). However, it does not explicitly contrast with assign_task or create_task.
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 mentions that at least one field in 'updates' is required and gives a typical use case (attaching SDD). But it lacks guidance on when to choose this tool over alternatives like move_task_and_update or assign_task, and does not mention prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0assign_taskcreate_taskmove_taskmove_task_and_updateupdate_taskEach tool targets a distinct operation (create, update, move, combine move+update, assign), but move_task and move_task_and_update could cause minor confusion for agents deciding between separate calls or a combined operation.
All tool names follow a strict verb_noun pattern using snake_case (create_task, update_task, move_task, etc.), making the naming highly predictable and consistent.
With 5 tools covering core task actions, the count is well-scoped for a focused task management server, neither too sparse nor excessive.
The set covers create, update, move, and assign operations, but lacks delete and any retrieval/list functionality, which may leave agents unable to fully manage the task lifecycle.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Task management for people and AI agents, with scoped OAuth access to issues, projects, and docs.
Verified, pay-per-use API tools for AI agents through one authenticated connection.
Connect AI agents to 1000+ apps with managed authentication and tool-calling.
Give your AI agents the tools to build, manage, and run automation workflows.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Pedro-Roger/upsprint-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
