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., "@Nusawave MCP Server get the repo overview"
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.
MCP tools to read local git repos and fetch public web pages — no SerpAPI or Firecrawl required.
One shared server.py runs as multiple MCP servers (one process per repo), configured via environment variables or JSON config files.
Tool | What it does |
| README + key root files when present |
| List markdown files under |
| Read any file inside the configured repo |
| HTTP fetch any public URL → plain text |
| Fetch live site sections — only when |
Related MCP server: Gitingest MCP Server
git clone https://github.com/YOUR_ORG/nusawave-mcp.git
cd nusawave-mcp
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
# Test on stdio (Ctrl+C to stop)
NUSAWAVE_REPO_PATH=/path/to/your/repo python server.pyOr with uv:
uv sync
NUSAWAVE_REPO_PATH=/path/to/your/repo uv run server.pyVariable | Default | Purpose |
|
| FastMCP server name (set per config entry) |
|
| Local clone path for this server process |
| (unset) | Live site base URL; required for |
The maintainers run one server entry per repo. Copy the example config and adjust paths:
cp typingmind-mcp-config.example.json typingmind-mcp-config.json
# edit paths in typingmind-mcp-config.jsonServer key | Example repo |
|
|
| Yes |
|
| No |
|
| No |
|
| No |
|
| No |
From this repo directory:
claude mcp add my-project \
-e NUSAWAVE_MCP_NAME=my-project \
-e NUSAWAVE_REPO_PATH=/path/to/your/repo \
-- /path/to/venv/bin/python /path/to/nusawave-mcp/server.py
claude mcp get my-projectThen run claude and ask it to use your MCP tools, e.g. “Use my-project to get the repo overview.”
If Claude Desktop runs on Windows but the repo lives in WSL, use a UNC path for --directory or invoke WSL explicitly. See examples/claude-desktop-config.json.
Minimal WSL example (merge into %APPDATA%\Claude\claude_desktop_config.json):
{
"mcpServers": {
"nusawave-my-project": {
"command": "wsl",
"args": [
"-d", "Ubuntu", "--",
"/home/USER/apps/mcp/nusawave/.venv/bin/python",
"/home/USER/apps/mcp/nusawave/server.py"
],
"env": {
"NUSAWAVE_MCP_NAME": "nusawave-my-project",
"NUSAWAVE_REPO_PATH": "/home/USER/apps/your-repo"
}
}
}
}Restart Claude Desktop after editing the config.
./start-connector.sh YOUR_AUTH_TOKENUse the same token shown in TypingMind → Settings → MCP. The script prints the exact URL to paste.
Critical: Connector URL must include the port:
URL | Result |
| Correct |
| Correct |
| Wrong — hits nginx on port 80 → 404 / "Update required" |
| Wrong — browsers cannot connect to |
Verify with:
./verify-connector.sh http://127.0.0.1:50880 YOUR_AUTH_TOKENSettings → Advanced → Model Context Protocol
Delete and re-setup MCP Connector (clears stale URL)
Choose Private MCP Connector (not TypingMind Cloud)
Paste connector URL and auth token from step 1
Wait for green check / Get Started
Click Edit Servers and paste your typingmind-mcp-config.json (copy from typingmind-mcp-config.example.json first).
Plugins → enable the servers you need → attach to your character.
"Update required… restart MCP Connector" — TypingMind got 404 on
/mcp-connect. Almost always a wrong Connector URL (missing:50880).
If TypingMind runs in Windows but this repo is in WSL, run the MCP connector inside WSL. Paths in the config must be valid on the machine where Python runs.
"Get the repo overview for my forecast project"
"Read docs/index.md and compare with the live site"
"Summarize the repository structure"
"Fetch https://example.github.io/ and summarize the homepage"
MIT — see LICENSE.
Fetch the live site homepage and key section pages as plain text.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description is the sole source of behavioral info. It only states the action (fetch) and output format (plain text), but omits authentication, rate limits, or failure behaviors. This is inadequate for a tool that likely accesses external websites.
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 with no unnecessary words. It efficiently conveys the tool's purpose.
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?
Although the tool has an output schema (unseen), the description lacks details on what 'key section pages' are and does not clarify the scope of the audit. Given the sibling tools, more context would help an agent decide between them.
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?
There are no parameters, so the baseline score is 4 per rubric. The description does not need to add parameter info since the schema is complete.
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 fetches the live site homepage and key section pages as plain text, which is specific. However, it does not differentiate from sibling tool 'fetch_public_page' which might fetch a single page; 'audit_live_site' implies multiple pages but 'key section pages' is vague.
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 on when to use this tool versus alternatives like 'fetch_public_page' or 'get_repo_overview'. An AI agent would not know the trade-offs or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a public web page (no API key). Good for GitHub Pages sites.
Args:
page_url: Full URL, e.g. https://nusawave-labs.github.io/
extract_text: If true, strip HTML to readable text (default true)
| Name | Required | Description | Default |
|---|---|---|---|
| page_url | Yes | ||
| extract_text | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses 'no API key' (authentication) and the extract_text behavior, but lacks details on error handling, rate limits, or handling of non-GitHub pages. Minimal behavioral info beyond parameter 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?
Extremely concise with two sentences plus args list. Purpose is front-loaded with no extraneous words. Every sentence adds 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?
Reasonably complete for a simple fetch tool with an output schema present. Covers purpose, parameter semantics, and usage context. Missing explicit error conditions or non-GitHub handling, but adequate overall.
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?
Despite 0% schema description coverage, the description adds meaningful parameter explanations: page_url example and extract_text meaning with default. This compensates well for the bare 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 'Fetch a public web page' and specifies it's good for GitHub Pages, distinguishing it from sibling tools like audit_live_site or read_repo_file. However, it lacks explicit differentiation from siblings.
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 usage for GitHub Pages sites but provides no when-not-to-use guidance or explicit alternatives among siblings like audit_live_site or get_repo_overview. Usage is inferred but not fully outlined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return README and key root files for the configured local repository.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description only states what is returned, not behaviors like read-only nature or caching. Lacks safety 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?
Single sentence, concise, no superfluous words. Front-loaded with clear purpose.
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?
Adequate for a zero-parameter tool with output schema, but could elaborate on what 'key root files' means. Mostly complete.
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?
No parameters in schema; description adds meaning by specifying what is returned (README and key root files). With 0 params, baseline is 4.
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?
Clearly states it returns README and key root files for the local repository. Distinct from siblings like list_docs and read_repo_file.
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?
Implied usage (when needing an overview) but no explicit guidance on when to use vs alternatives like list_docs or read_repo_file.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List markdown files under docs/ in the local repo.
Args:
pattern: Glob relative to docs/ (default: all markdown files).
| Name | Required | Description | Default |
|---|---|---|---|
| pattern | No | **/*.md |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It explains the pattern parameter and default glob, but does not disclose whether the operation is read-only, safe, or any side effects. However, for a listing tool, this is minimally adequate.
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 with minimal yet complete information, front-loaded with the purpose. No redundant sentences.
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 list tool with one parameter and an output schema present, the description is largely complete. It could mention that the glob includes subdirectories, but the default glob implies recursive listing.
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 0%, but the description adds meaning: 'Glob relative to docs/' clarifies the parameter's role and default behavior beyond the schema's type and default.
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 lists markdown files under the docs/ directory in the local repo, distinguishing it from sibling tools like read_repo_file or fetch_public_page.
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 does not explicitly state when to use this tool versus alternatives or when not to use it. Usage is implied but lacks exclusions or comparative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a file from the configured local repository.
Args:
relative_path: Path relative to repo root, e.g. docs/index.md or zensical.toml
max_chars: Maximum characters to return (default 50000)
| Name | Required | Description | Default |
|---|---|---|---|
| relative_path | Yes | ||
| max_chars | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and description only states basic read action. Does not disclose error handling, size limits, encoding, or other behavioral traits. For a tool with no annotations, 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?
Two-line description plus parameter docs, front-loaded purpose, no redundant words. Efficient and clear.
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?
Covers the basic action and parameter semantics, but lacks behavioral context (e.g., error on missing file) and usage guidance. Given output schema exists, return value description is not required, but tool still feels incomplete.
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?
Description adds meaningful parameter details: provides example path format, notes default for max_chars. Schema description coverage is 0%, so description compensates well.
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?
Clearly states 'Read a file from the configured local repository' with a specific verb and resource. Differentiates from sibling tools like audit_live_site and fetch_public_page that deal with web resources.
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?
Implies usage for reading local repo files but lacks explicit when-to-use or when-not-to-use guidance. No mention of alternatives or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct purpose: live site auditing, generic page fetching, repo overview, doc listing, and file reading. No two tools have overlapping functionality.
All tools follow a consistent verb_noun snake_case pattern (audit_live_site, fetch_public_page, get_repo_overview, list_docs, read_repo_file), making them predictable.
With only 5 tools, the server is tightly scoped to auditing and repository access. Each tool is necessary and the count fits the domain well.
Core operations for auditing (live site fetch, repo docs, file reading) are covered. Minor gaps exist, such as a dedicated comparison tool, but agents can combine existing tools to achieve similar results.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Source-first URL clone, capture, rebuild, and fidelity verification tools.
A simple tool that performs a fetch request to a webpage.
Screens public GitHub repos and PRs to generate risk maps, findings, and merge-readiness signals.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/monsunic/mcp-nusawave'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
