wiki-helper
mcp-wiki-helper-tools
Servidor MCP para consultar uma Wiki armazenada em um repositório Git.
Ele sincroniza a Wiki, indexa os arquivos Markdown e oferece ferramentas para listar, pesquisar e ler documentos no Codex ou no VS Code.
Funcionalidades
Ferramenta | O que faz |
| Verifica se o MCP está funcionando. |
| Lista os documentos da Wiki. |
| Pesquisa pelo nome ou caminho do documento. |
| Pesquisa dentro do conteúdo dos documentos. |
| Lê um documento Markdown completo. |
Related MCP server: py-mcp-wiki-helper
Como funciona
O MCP clona ou atualiza o repositório Git da Wiki.
Localiza todos os arquivos
.md.Cria um índice em memória.
Disponibiliza as ferramentas pela rota HTTP
/mcp.Atualiza a Wiki periodicamente.
A pasta definida em
WIKI_LOCAL_PATHé atualizada comgit reset --hard. Não faça alterações manuais nela, pois serão descartadas.
1. Configurar o servidor
Na máquina onde o MCP ficará rodando, entre na pasta do projeto:
cd "/caminho/para/mcp-wiki-helper"Instale as dependências:
npm installCrie o arquivo .env:
cp .env.example .envPreencha o .env:
WIKI_REPOSITORY_URL=git@github.com:empresa/wiki.git
WIKI_LOCAL_PATH=./data/wiki
WIKI_BRANCH=main
WIKI_SYNC_INTERVAL_MS=1800000
MCP_HTTP_HOST=0.0.0.0
MCP_HTTP_PORT=3000
MCP_HTTP_ROUTE=/mcpPara facilitar o primeiro teste na rede local, não configure MCP_API_KEY.
2. Iniciar o servidor
Compile:
npm run buildInicie:
npm run start:httpMantenha esse terminal aberto. A mensagem esperada é:
[MCP] HTTP ativo em http://0.0.0.0:3000/mcpDescubra o IP da máquina:
hostname -ISe necessário, libere a porta na rede local:
sudo ufw allow from 192.168.0.0/16 to any port 3000 proto tcp3. Testar a conexão
Na outra máquina, execute:
curl http://IP_DO_SERVIDOR:3000/healthExemplo:
curl http://192.168.3.233:3000/healthResposta esperada:
{
"status": "ok",
"documents": 100
}O campo documents deve ser maior que zero.
4. Conectar no Codex
No Codex:
Abra Settings.
Entre em MCP servers.
Clique em + Add server.
Escolha o tipo URL/HTTP.
Use o nome
wiki-helper.Preencha somente a URL:
http://IP_DO_SERVIDOR:3000/mcpExemplo:
http://192.168.3.233:3000/mcpDeixe estes campos completamente vazios:
Bearer token env var
Headers
Headers from environment variables
Não escreva none nos campos de autenticação.
Depois:
Salve o servidor.
Ative a chave ao lado de
wiki-helper.Abra uma conversa nova no Codex.
Envie:
Use list_documents do MCP wiki-helper e mostre os primeiros 10 documentos.Se o Codex informar que a variável de ambiente none não existe:
Abra Settings > MCP servers > wiki-helper.
Clique em Uninstall.
Adicione novamente preenchendo somente a URL.
Deixe todos os campos de autenticação vazios.
5. Conectar no VS Code/Copilot
No VS Code:
Pressione
Ctrl+Shift+P.Execute
MCP: Open User Configuration.Coloque no arquivo
mcp.json:
{
"servers": {
"wiki-helper": {
"type": "http",
"url": "http://IP_DO_SERVIDOR:3000/mcp"
}
}
}Depois execute MCP: List Servers, selecione wiki-helper e escolha Start Server.
6. Exemplos de uso
Verificar o servidor:
Use a ferramenta Server do MCP wiki-helper.Listar documentos:
Use list_documents do wiki-helper e mostre os primeiros 10 documentos.Pesquisar pelo nome:
Use search_documents do wiki-helper para procurar "autenticação".Pesquisar dentro da Wiki:
Use search_content do wiki-helper para pesquisar "JWT", com limite 5.Ler um documento:
Use read_document do wiki-helper para ler "caminho/documento.md" e faça um resumo.Problemas comuns
Erro ECONNREFUSED ...:80
A URL está sem a porta ou a rota. Use sempre:
http://IP_DO_SERVIDOR:3000/mcpAbriu a rota /authorize
O cliente tentou usar OAuth. Este MCP não possui OAuth. Remova a autenticação e deixe os campos Bearer e Headers vazios.
O MCP não conecta
Confira na máquina servidora:
npm run start:http
ss -lntp | grep 3000Teste novamente na máquina cliente:
curl http://IP_DO_SERVIDOR:3000/healthA Wiki não retorna documentos
Confira se a pasta configurada contém arquivos Markdown:
find ./data/wiki -type f -name '*.md' | headTambém confira o acesso ao repositório Git configurado em WIKI_REPOSITORY_URL.
Segurança
Use este modo sem autenticação apenas em uma rede local controlada.
Não exponha a porta
3000diretamente na internet.Para acesso externo, utilize HTTPS, autenticação e um proxy reverso.
Nunca versione chaves ou credenciais no
.env.
Available Tools
5 toolslist_documentsList DocumentsB
Lista todos os documentos disponíveis na Wiki.
| 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 of behavioral disclosure. It only states that the tool lists documents, but it does not describe what the returned list contains (e.g., IDs, titles, pagination, ordering, or whether it returns the full set or a sample). For a tool with no annotations and no output schema, this is insufficient for an agent to predict the tool's 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 a single sentence in Portuguese that is direct and front-loaded with the core action and object. There is no extraneous information, and it is appropriately concise for a tool with no parameters.
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?
The tool has no output schema and no annotations, so the description must compensate. It only says 'lists all documents' but does not specify what fields are returned, whether the result is paginated, or any other details an agent might need to consume the output. For a potentially large list, this is a notable gap.
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 zero parameters, and the schema coverage is trivially 100%. Per the calibration rules, when there are no parameters the baseline score is 4. The description does not need to explain parameters that don't exist, and it correctly avoids inventing any.
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 ('Lista' = list) and the resource ('todos os documentos disponíveis na Wiki' = all documents available in the Wiki). It is distinct from the sibling tools by name and verb (list vs. search/read), but it does not explicitly call out the differentiation, so it loses a point for not addressing the sibling context.
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 the search or read tools. There is no mention of use cases, limitations, or alternatives. An agent would have to infer that list_documents is for enumerating all documents, but it has no explicit instruction on when that is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
read_documentRead DocumentB
Lê o conteúdo de um documento da Wiki pelo caminho.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Caminho do documento, por exemplo: "software/JWT.md" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states that reading returns content, but does not mention error behavior for nonexistent paths, response format, or any side effects (though likely safe). This is a significant gap for a tool with zero annotation context.
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 with no filler. The core action and resource are front-loaded, making it easy to parse quickly.
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 read tool with one parameter and no output schema, the description is adequate but not thorough. It explains the purpose and parameter, but lacks information about return value format or error handling, which would be useful without an output schema to clarify.
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%, with the 'path' parameter described and an example provided. The tool description adds no extra meaning about parameters beyond what the schema already covers, so the baseline score of 3 applies.
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 (read), the resource (document content of the Wiki), and the method (by path). This distinguishes it from siblings like list_documents (listing) and search_documents/search_content (searching), so an agent can differentiate without extra info.
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 given on when to use this tool versus alternatives. There is no mention of conditions like 'use this when you have a known path' or exclusions against using search tools. The context is minimal and relies on inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_contentSearch Wiki ContentC
Pesquisa termos dentro do conteúdo dos documentos Markdown da Wiki.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Quantidade máxima de documentos retornados. | |
| query | Yes | Termos que devem ser pesquisados na Wiki. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states the search action and target content, but omits details like case sensitivity, matching behavior, result ordering, or what happens with no matches. This is minimal and does not go beyond the schema.
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, but it is in Portuguese and adds no value beyond the schema. It is not overloaded, yet it also lacks useful context or differentiation, so it is acceptable but minimal.
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 two parameters and no output schema, the description does not explain return format, errors, or how it differs from the very similar sibling 'search_documents'. This incompleteness could lead to incorrect usage or choice of the wrong tool, so more detail is needed.
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 both 'query' and 'limit' thoroughly. The description does not add any extra meaning about parameters; it only restates that it searches terms, which matches the schema's existing text. Baseline of 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 tool searches terms within wiki Markdown content, using a specific verb and resource. However, it does not differentiate from the sibling tool 'search_documents', which appears to have a nearly identical purpose, leaving ambiguity about which search tool to pick.
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?
There is no guidance on when to use this tool rather than alternatives like 'search_documents', 'list_documents', or 'read_document'. The description only says what it does, not when to use it, so an agent gets no context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_documentsSearch DocumentsC
Busca documentos da Wiki pelo nome ou caminho.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Texto para pesquisar. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations to back up the description, so the description carries the full burden of disclosing behavioral traits. It merely states what is searched (name/path) but does not disclose the nature of the search (exact match, fuzzy), whether results are paginated, what is returned (list of documents? paths?), or any side effects. Since it's a search, it's likely read-only, but that isn't stated. This is a significant gap.
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, clear sentence that front-loads the main action and scope. No unnecessary words. It is concise and readable. It would earn a 5 if it included a bit more useful context, but for its brevity it is well-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?
For a simple search tool with one parameter and no output schema, the description should explain what the result looks like (e.g., a list of matches) or mention any limitations. It lacks this. Additionally, because there is a sibling 'search_content', the description should clarify the difference, but it doesn't. The description is too minimal to fully equip an agent to call the tool correctly.
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 schema covers 100% of the parameter (query) with a description ('Texto para pesquisar.'). The tool description adds no additional meaning about the parameter's semantics, such as case sensitivity, wildcards, or format. With full schema coverage, the baseline is 3, and the description does not exceed it.
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 a specific verb ('busca' – search), a resource ('documentos da Wiki' – Wiki documents), and a scope ('pelo nome ou caminho' – by name or path). This gives a clear purpose and implicitly differentiates from the sibling 'search_content' (which likely searches content). However, it does not explicitly name the sibling or articulate the differentiation, so it stops short of a 5.
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 the alternatives (list_documents, read_document, search_content). It does not mention exclusions, prerequisites, or contexts where another tool would be more appropriate. Without this, an agent may struggle to choose the correct tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ServerServer checkA
Verifica se o servidor MCP está funcionando.
| 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 of behavioral disclosure. It only says 'verifies if the server is working' without specifying what the response looks like (e.g., a status field, a boolean, an error-free execution), or whether there are any side effects. This is a significant gap for a tool that an agent must interpret.
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, tightly worded sentence. It is front-loaded with the core action and resource, with no filler. For a tool with no parameters, this is appropriately sized.
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 has no output schema and no annotations, the description must explain what an agent can expect from a call. It only states the check occurs but does not describe the return value, possible error conditions, or how to interpret the result. This is incomplete for a tool that an agent would call and need to act on.
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?
With zero parameters, the schema has 100% coverage (no params to describe). Per the rubric, a 0-parameter tool gets a baseline of 4, and the description does not need to add parameter-specific meaning.
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 a clear verb ('Verifica' / checks) and a specific resource (the MCP server), making the tool's purpose unambiguous. It is also clearly distinct from the sibling tools (which are all document-related), so an agent can tell it apart without extra context.
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 implies it is for checking server health, but gives no explicit guidance on when to use it versus alternatives. Since the siblings are unrelated, there is no confusion, but no explicit when/when-not or alternative naming is provided.
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.
5 tool updates
v1.0.0- First observed
list_documents - First observed
read_document - First observed
search_content - First observed
search_documents - First observed
Server
TDQS
Scored across 5 tools
Each tool has a clear, distinct purpose: health check, list all documents, read by path, search by name/path, and search content. No overlap or ambiguity exists among the tool operations.
Most tools follow a consistent verb_noun pattern (list_documents, read_document, search_documents, search_content). The lone exception is 'Server,' which is a single-word health check and slightly breaks the pattern, but it remains readable and predictable.
At 5 tools, the server is well-scoped for a wiki helper. Each tool covers a fundamental operation without redundancy or bloat, and the count is within the ideal 3-15 range.
The surface provides list, read, and two search capabilities, covering the primary read-only workflows for a wiki. It lacks create/update/delete operations, but these may be intentionally out of scope for a helper; minor gaps exist but are easily worked around by external tools.
Maintenance
Related MCP Connectors
Shared project wiki for AI agents: read and write pages, next actions, and activity logs over MCP.
Hosted markdown project wikis your team's AI assistants read, search, and update over MCP.
Read-only MCP server for the OrchestKit docs: full-text search + Markdown fetch. No auth.
Read and write your team's shared, AI-readable wiki from any MCP client.
Related MCP Servers
- FlicenseNot gradedqualityCmaintenanceServes markdown knowledge from a git repository over MCP, providing tools to list, search, and retrieve documents.-
- AlicenseNot gradedqualityCmaintenanceMCP server to query a Git-hosted Wiki, offering tools to list, search, and read Markdown documents via Codex or VS Code.MIT
- FlicenseNot gradedqualityDmaintenanceProvides structured search, schema-validated writes, and linting for a markdown knowledge base, enabling agents to operate the wiki over a single streamable-HTTP MCP endpoint.1-
- AlicenseNot gradedqualityCmaintenanceEnables read-only searching, reading, and status inspection of a local Git-backed Markdown wiki via a minimal MCP toolset, without any network or write operations.Apache 2.0