Which integrations are available for this server?

Fetches source code and documentation for Industrial Ecology packages from GitHub, enabling version-specific code retrieval and precise answers. Checks installed package versions from PyPI to look up the correct documentation and source code for the exact versions in use.

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ie-mcp How do I use brightway2 to create a database?" 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.

ie-mcp

by JonasKlimt

Overview Schema Related Servers Score Discussions

Python

Local

ie_mcp

Python License MCP Packages

Using the ie_mcp server makes coding with AI agents and Industrial Ecology packages, especially Brightway, much easier. It guides GitHub Copilot to the right package documentation for your question, so you avoid mixed package versions, wrong references, and hallucinated answers. Ask it anything about a registered package (installation, usage, API, concepts) directly from VS Code Copilot.

NOTE

What is an MCP server?

An MCP (Model Context Protocol) server is a bridge between Copilot and trusted external information. Check this link to learn more about MCP servers: https://modelcontextprotocol.io/docs/getting-started/intro. In the case of the ie_mcp server Copilot can call this server to check package docs, source code, and versions before it answers.

Currently supported packages: The full Brightway LCA ecosystem, and additional industrial ecology tools — 56 packages total (see Brightway ecosystem and Additional packages below)

Why?

For modelling work, you need reliable help that matches your real environment and package versions. This server gives environment- and version-relevant explanations for both single functions and complete IE package workflows. This makes going through pages of package documentation and checking its GitHub pages redundant. Copilot can access information about the package and get relevant explantion/coding help for the exact package version you are using.

Related MCP server: Context7 MCP Server

Example questions

"How do I do a basic LCA in Brightway from setup to first result?"
"How do I use premise for prospective LCA scenarios?"
"How do I use the function [...]?
"Explain what arguments the function takes in the package version that is currently installed in my environment."
...

Prerequisites

Run the following in your environment:

pip install "mcp[cli]>=1.0.0" "httpx>=0.27.0" "beautifulsoup4>=4.12.0" "markdownify>=0.13.0"

Setup

1. Clone the repo

git clone https://github.com/JonasKlimt/ie_mcp.git
cd ie-mcp

2. Connect to your AI client

1st Option: Use the mcp server from within this clonded (which then becomes your local) repository

The .vscode/mcp.json file is already configured. Open this folder as your workspace root in VS Code and Copilot agent mode picks up the server automatically — no manual startup needed. This is recommended if you just want to get answers for questions.

2nd Option: Use the mcp server in your project

If you want to use the server in your project to answer questions and help you code, you need to add the following to your project. The server will still run in the local cloned repository but you will have access to it within your project.

Other workspaces / projects: To use the server from a different project, add it to your VS Code user settings (settings.json) with an absolute path:
{
  "mcp.servers": {
    "ie-mcp": {
      "type": "stdio",
      "command": "/absolute/path/to/your/environment/python.exe",
      "args": ["run", "/absolute/path/to/ie-mcp/server.py"],
      "env": {
         "GITHUB_TOKEN" : ""
      }
    }
  }
}

3. Point the server at the right Python environment

The server checks your installed package versions to look up the correct documentation and source code. It can only see packages installed in the Python interpreter specified in mcp.json (or user settings.json).

WARNING

Your working environment: set command to the same Python executable you use for your work. E.g.: conda (C:\Users\you\miniconda3\envs\bw\python.exe), venv in project folder (./venv/Scripts/python.exe)

NOTE

For best results, also add the instruction file (.github/copilot-instructions.md) in the .github folder to you repository. An instruction file is a short set of project-specific rules for Copilot (what tools to prefer, how to answer, what context matters most). This makes ie_mcp more efficient because Copilot is guided to use the server consistently and query package docs/versions in the way you want.

GitHub token (optional)

TIP

Thesearch_source and get_function_source tools use the GitHub REST API. Without a token, GitHub allows 60 requests/hour — enough for light use. Add a free personal access token to raise the limit to 5 000 requests/hour.

Go to github.com → Settings → Developer settings → Personal access tokens → Tokens (classic)
Click Generate new token (classic), give it a name, set an expiry — no scopes needed for public repos.
Add the token to your client config:

VS Code — paste into .vscode/mcp.json:

{
  "mcp.servers": {
    "ie-mcp": {
      "type": "stdio",
      "command": "/absolute/path/to/your/environment/python.exe",
      "args": ["run", "/absolute/path/to/ie-mcp/server.py"],
      "env": {
        "GITHUB_TOKEN" : "ghp_your_token"
      }
    }
  }
}

IMPORTANT

Do not commit.vscode/mcp.json after adding your token. The empty-token version is checked in so other users get a working starting point; your filled-in version is for local use only.

How the server works

It checks your active Python environment and installed package versions.
It fetches official documentation pages when needed and keeps a local cache for faster repeated use.
For version-specific questions, it checks GitHub tags first and then fetches matching source code.
When versioned docs are available (for example on ReadTheDocs), it can fetch those too.
If versioned docs are not available, it still answers from the matching versioned source code.

This keeps answers reliable, version-correct, and grounded in official docs or source.

Brightway ecosystem

Brightway is an open-source Python framework for life cycle assessment (LCA). All packages from the brightway-lca GitHub organisation are registered:

Meta-packages

Package key	PyPI / install	Description
`brightway25`	`pip install brightway25`	Brightway 2.5 — current stable meta-package
`brightway2`	`pip install brightway2`	Brightway 2 — legacy stable meta-package

Brightway 2.5 core components

These are the direct dependencies installed by pip install brightway25:

Package key	PyPI name	Role
`bw2data`	bw2data	Project & database management
`bw2calc`	bw2calc	LCA matrix calculations
`bw2io`	bw2io	Import / export (ecoinvent, SimaPro, …)
`bw2analyzer`	bw2analyzer	Contribution analysis & supply chain traversal
`bw2parameters`	bw2parameters	Parameter storage & formula evaluation
`bw_processing`	bw_processing	Structured NumPy datapackages
`matrix_utils`	matrix_utils	MappedMatrix building from datapackages
`bw_migrations`	bw_migrations	Migration files between ecoinvent versions
`bw_simapro_csv`	bw_simapro_csv	SimaPro CSV parsing
`ecoinvent_interface`	ecoinvent_interface	Programmatic ecoinvent download
`multifunctional`	multifunctional	Multi-output / allocation handling
`randonneur`	randonneur	Flexible dataset transformation engine
`randonneur_data`	randonneur_data	Transformation data files for randonneur
`stats_arrays`	stats_arrays	Uncertain parameter arrays & Monte Carlo
`mrio_common_metadata`	mrio_common_metadata	MRIO datapackage schema

Additional brightway-lca packages

Package key	Description
`bw_temporalis`	Time-explicit LCA (Brightway 2.5)
`bw_timex`	Advanced time-explicit LCA
`dynamic_characterization`	Dynamic (time-dependent) characterization factors
`bw_graph_tools`	Supply chain graph traversal utilities
`bw_exiobase`	EXIOBASE MRIO import
`bw_recipe_2016`	ReCiPe 2016 LCIA method
`bw_aggregation`	Aggregated process support
`bw_campaigns`	Named datapackage campaign management
`bw_hestia_bridge`	HESTIA API bridge
`bw_interface_schemas`	Pydantic interface schemas
`bw_simple_graph`	Lightweight graph backend (no bw2data)
`edge_of_the_world`	Experimental backend for richer exchange descriptions beyond standard matrix structure
`brightway2_regional`	Regionalized LCA calculations
`brightway_olca`	openLCA IPC server integration
`brightway_hybrid`	Hybrid IO/process LCA
`ecoinvent_migrate`	Randonneur migration file generator
`pedigree_matrix`	Pedigree-matrix uncertainty adaptation
`pyecospold`	EcoSpold1/2 XML ↔ Python round-trip
`pyilcd`	ILCD XML ↔ Python round-trip
`simapro_ecoinvent_elementary_flows`	SimaPro ↔ ecoinvent flow mappings
`simple_regional`	Lightweight regionalized LCA
`brightway2_speedups`	Cython performance extensions for BW2
`brightway2_ui`	CLI tool for Brightway2

Additional packages

LCA tools

Package key	GitHub	Docs	Description
`edges`	edges	readthedocs	Edge-based LCIA for Brightway: context-sensitive characterization factors applied to exchanges, not just flows. Includes AWARE 2.0, ImpactWorld+, GeoPolRisk, GLAM3.
`lca_algebraic`	lca_algebraic	readthedocs	Parametric LCA inventories with fast Monte Carlo and Sobol sensitivity analysis, using Sympy expressions. Built on Brightway2/2.5.
`pathways`	pathways	readthedocs	Scenario-driven transformations for LCI datasets and workflows, designed for prospective and pathway-based LCA use cases.
`regioinvent`	Regioinvent	GitHub README	Automatically regionalizes ecoinvent by connecting it to the BACI trade database, creating national production processes and consumption markets.

Material flow analysis (MFA)

Package key	GitHub	Docs	Description
`flodym`	flodym	readthedocs	Flexible Open Dynamic Material Systems Model — Python library for dynamic MFA with dimension-aware arrays (FlodymArray), stock accumulation with age-cohort tracking, and Pydantic-typed system setup. Adaptation of ODYM.
`odym`	ODYM	readthedocs	Open Dynamic Material Systems Model — Python framework for dynamic material flow analysis with object-based system description and dynamic stock modeling.
`recc_odym`	RECC-ODYM	GitHub README	Resource Efficiency–Climate Change mitigation model built on ODYM. Dynamic MFA of vehicles and buildings across SSP scenarios; assesses 10 material efficiency strategies.

Environmentally extended input output analysis

Package key	GitHub	Docs	Description
`pymrio`	pymrio	readthedocs	Multi-regional input-output (EE MRIO) analysis: auto-download and parse EXIOBASE, WIOD, EORA26, OECD, GLORIA; calculate footprints, trade-embodied impacts.

Adding a new package

Let us know if you are missing any package! You can also add an addtional package yourself:

Create packages/{name}/ with an __init__.py.
Create packages/{name}/metadata.py with a METADATA dict. Copy packages/premise/metadata.py as a template — the key fields are:
- name, description, github_url, github_repo, readthedocs_slug, docs_url, install, sections
- Each section needs id, title, url, description.
Run the fetch script: python scripts/fetch_docs.py --package {name}
Restart the server — the new package is discovered automatically.

No changes to server.py or any core file are needed.

Contibutions are welcome!

License

BSD-3-Clause

Available Tools

11 tools

fetch_latest_docsA

Force-fetch documentation for a package directly from the web, bypassing the local cache. Use this when the user wants the most up-to-date content or when cached content may be stale.

The fetched page is written to the local cache so later calls are fast. Fetches a specific section page if given, otherwise the docs homepage.

Args: package: Package name as returned by list_packages(). section: Optional section id (e.g. 'introduction', 'faq'). Leave empty to fetch the docs homepage. version: Docs version slug (default: 'latest'). Use list_doc_versions() to discover available versions.

ParametersJSON Schema

Name	Required	Default
`package`	Yes
`section`	No
`version`	No	latest

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, description carries full burden. It discloses cache bypassing, caching of fetched page, and behavior for section vs homepage. Lacks mention of potential errors or network implications, but adequate for a fetch tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Concise paragraph with clear purpose first, then details and Args section. Each sentence adds value. Could be slightly tighter but well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers main behaviors: cache bypassing, caching, fetching homepage or section, parameter defaults. Output schema exists so return values need no explanation. Complete for a 3-param tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

All three parameters are well explained with examples ('introduction', 'latest') and cross-references (list_packages(), list_doc_versions()). Adds value beyond schema's basic types.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it force-fetches documentation from the web bypassing cache, and distinguishes from siblings by emphasizing freshness. It also specifies fetching a section or the homepage.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says use when user wants up-to-date content or stale cache. Does not list alternatives among siblings but provides context by mentioning caching behavior.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_doc_sectionA

Return the full Markdown content of a specific documentation section.

The first call fetches the live docs page and caches it locally. Later calls are served from the cache.

Defaults to the latest version. Call list_doc_versions(package) first if the user asks about a specific older version.

Call get_package_info(package) first to discover the available sections.

Args: package: Package name as returned by list_packages(). section: Section id (e.g. 'introduction', 'faq'). version: Docs version slug (default: 'latest'). Use list_doc_versions() to discover available versions.

ParametersJSON Schema

Name	Required	Default
`package`	Yes
`section`	Yes
`version`	No	latest

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but the description fully discloses caching behavior: 'The first call fetches the live docs page and caches it locally. Later calls are served from the cache.' It also implies a read-only, non-destructive operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description starts with a concise purpose, then uses clear paragraphs for usage guidelines and parameter details. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema, the description does not need to detail return values. It covers caching, prerequisites, and parameter sources, making it fully complete for an agent to use the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description compensates by explaining each parameter: package as from list_packages(), section with examples, and version with default and reference to list_doc_versions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states 'Return the full Markdown content of a specific documentation section' with a clear verb and resource. It distinguishes from sibling tools like search_docs and fetch_latest_docs by specifying it returns a single section's content and mentions caching behavior.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly advises calling get_package_info first to discover sections and list_doc_versions before using a specific version. This guides the agent on prerequisites and when to use alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_function_sourceA

Find a function in the package's GitHub source code and return its full source, including docstring and signature.

Searches the repository for files containing the function name, then uses Python's ast module to extract the exact function definition. The raw source file is cached locally after the first fetch.

If a version is given, the file is fetched at that GitHub tag. Call list_source_versions(package) first to confirm the version tag exists.

Only returns an error if the version tag does not exist, or if the function was not present in the codebase at that version.

Args: package: Package name as returned by list_packages(). function_name: Exact name of the function or method to retrieve. version: Optional version tag (e.g. 'v2.1.0' or '2.1.0'). Omit to get the current (latest) implementation.

ParametersJSON Schema

Name	Required	Description	Default
`package`	Yes
`version`	No
`function_name`	Yes

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses caching behavior, version tag fetching, and error conditions. However, it does not mention potential rate limits or authentication needed for GitHub access.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with clear paragraphs and bullet-like Args list. Front-loaded with purpose. Could be slightly more concise, but every sentence adds value and there is no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, the description outlines the return value ('full source, including docstring and signature') and error conditions. Given the complexity (caching, versioning), it is complete and thorough.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description fully compensates. Each parameter is explained: package as returned by list_packages(), function_name as exact name, version with examples and default. This adds meaning beyond the schema titles.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's action: 'Find a function ... and return its full source'. It specifies the resource (function source code) and distinguishes from siblings by referencing list_source_versions for version verification.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly guides when to use the tool and what prerequisites exist: 'call list_source_versions(package) first to confirm the version tag exists'. It also explains when errors are returned, providing clear context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_installed_package_versionA

Check what version of a package is installed in the MCP server's Python environment.

Returns the installed version and the Python executable path so users can verify which environment is being checked. Always call this before get_function_source or get_doc_section when the user has not specified a version, to ensure the documentation and source code match their actual installation.

If the package is not installed, the response includes guidance on pointing mcp.json to the right Python environment.

Args: package: Package name as returned by list_packages().

ParametersJSON Schema

Name	Required	Description	Default
`package`	Yes

TDQS

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Describes return values (version and Python path) and behavior when package is not installed (guidance on mcp.json). No annotations exist, so description carries full burden. Could mention that it is read-only and has no 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.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Reasonably concise; covers purpose, usage, return, and error handling in a few sentences. Could be slightly tighter by removing redundant phrasing like 'so users can verify which environment is being checked'.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given one parameter, no output schema, and no annotations, the description is highly complete: explains what it does, what it returns, when to use it, and what happens in error cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% description coverage, but description adds meaning: 'Package name as returned by list_packages()'. This links the parameter to the sibling tool list_packages, providing helpful context beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the verb 'Check what version' and the resource 'package installed in the Python environment'. Distinguishes from siblings by specifying when to call this tool before get_function_source or get_doc_section.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly tells when to use this tool: 'Always call this before get_function_source or get_doc_section when the user has not specified a version'. Provides context about environment verification and error handling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_package_infoA

Get metadata for a package: description, GitHub URL, docs URL, install commands, and the list of available documentation sections.

Args: package: Package name as returned by list_packages().

ParametersJSON Schema

Name	Required	Description	Default
`package`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Since no annotations are provided, the description carries the full burden. It clearly indicates that the tool retrieves metadata without side effects, and lists the exact pieces of metadata returned. This is transparent for a read-only operation, though it does not mention error conditions or pagination.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise: two sentences covering purpose and parameter, with no fluff. It is front-loaded with the core action and easily scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite lacking an output schema, the description enumerates the returned metadata fields, which is sufficient for an agent to understand what to expect. It does not specify the exact structure (e.g., JSON keys), but given the tool's simplicity, this is adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema only defines 'package' as a string with no description, yielding 0% schema coverage. The description compensates by adding context: 'Package name as returned by list_packages()'. This provides valuable usage guidance beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get metadata for a package' and enumerates specific items (description, GitHub URL, docs URL, install commands, available documentation sections). It effectively distinguishes from siblings like list_packages (which returns package names) and fetch_latest_docs (which fetches documentation).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides a usage hint by noting that the 'package' argument should come from 'list_packages()'. However, it does not explicitly state when to use this tool versus alternative siblings like get_doc_section or get_function_source.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_server_environmentA

Inspect the MCP server's Python environment.

Returns the Python executable path, Python version, and the installed version of every package registered in this server. Use this to verify that the MCP server is running in the correct environment before asking about specific packages. If a package shows 'not installed', update the 'command' field in .vscode/mcp.json to point to the Python where you have your packages installed.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description fully discloses the tool's behavior: it returns the Python executable path, version, and installed versions of every package. No side effects are expected; it is a read-only inspection tool, and the description accurately reflects that.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, consisting of two short sentences that front-load the purpose. Every sentence serves a clear function: stating what it returns and when to use it. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no parameters and no output schema, the description is complete. It explains exactly what the tool returns and provides usage context. No additional information is needed for an agent to use it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so there are no parameters to describe. The baseline for no parameters is 4. The description does add value by explaining the return values, which is relevant but falls under parameter semantics only indirectly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it inspects the MCP server's Python environment, listing the Python executable path, version, and installed packages. This distinguishes it from sibling tools like get_installed_package_version and list_packages, which have narrower scopes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly tells when to use the tool (to verify the correct environment before asking about specific packages) and what to do if a package is not installed (update command in .vscode/mcp.json). This provides clear context and actionable guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_doc_versionsA

List all available documentation versions for a package.

Queries the ReadTheDocs API to discover published versions. Always call this before get_doc_section or search_docs when the user asks about a specific version other than the latest.

Args: package: Package name as returned by list_packages().

ParametersJSON Schema

Name	Required	Description	Default
`package`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.2/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description mentions it 'Queries the ReadTheDocs API to discover published versions,' indicating a network call. No annotations are provided, so the burden is on the description. It does not disclose potential side effects, authentication needs, or rate limits, but as a read-only list operation, this is moderately acceptable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise: two sentences plus an Args block. It front-loads the purpose, then adds usage context and parameter guidance. Every sentence serves a distinct purpose without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one parameter, output schema exists), the description adequately covers the core function and usage context. It lacks details on error cases or network dependencies, but it is sufficient for an agent to select and invoke the tool correctly in most scenarios.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema contains only the 'package' parameter with no description. The description adds 'Package name as returned by list_packages().' This provides a helpful source hint, guiding the agent to use the correct value format. Schema coverage is 0%, so this compensation is valuable.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description begins with 'List all available documentation versions for a package,' which is a specific verb+resource combination. It further distinguishes the tool by stating it should be called before get_doc_section or search_docs for non-latest versions, showing its unique prerequisite role among siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states 'Always call this before get_doc_section or search_docs when the user asks about a specific version other than the latest.' This gives clear when-to-use guidance. It does not mention when not to use it, such as for the latest version, but the context implies alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_packagesA

List all Python packages that this MCP server has documentation for.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It only states the basic purpose of listing packages, but does not disclose any behavioral traits such as whether the operation is read-only, pagination behavior, rate limits, or authentication requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single clear sentence of 13 words with no unnecessary information, perfectly sized for its simple purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless list operation with an output schema (not shown), the description is sufficiently complete. It conveys the essential purpose without needing to detail return values. However, it could mention that the list is of packages with documentation, which it does.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has no parameters (input schema is empty), so the description need not add parameter meaning. With 0 parameters, baseline is 4; the description is adequate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'list', the resource 'Python packages', and the scope 'that this MCP server has documentation for'. It is specific and distinguishes from sibling tools like get_package_info which would return details for a single package.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the use case of enumerating documented packages, but provides no explicit guidance on when to use this tool versus alternatives like get_package_info or search_docs, nor any conditions when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_source_versionsA

List all available source code versions (GitHub tags) for a package.

Use this when the user asks about a specific version of a function, to confirm the version exists before calling get_function_source.

Args: package: Package name as returned by list_packages().

ParametersJSON Schema

Name	Required	Description	Default
`package`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses the operation (listing) and is straightforward. However, it does not mention potential pagination or limitations, but for a simple list tool this is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Very concise: 3 sentences total. Front-loaded with purpose, then usage note, then parameter description. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an output schema exists, description need not explain return values. It fully explains the single input parameter with a reference to another tool, making it complete for a simple list operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but description adds crucial context: 'Package name as returned by list_packages().' This tells the agent how to obtain the parameter value, compensating for the lack of schema description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'List all available source code versions (GitHub tags) for a package.' It uses a specific verb ('list') and resource ('source code versions'), and distinguishes from siblings like 'get_function_source' and 'list_packages'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance: 'Use this when the user asks about a specific version of a function, to confirm the version exists before calling get_function_source.' It tells when to use and names an alternative tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_docsA

Search the package documentation for a query string.

Missing pages are fetched live and cached before searching. Returns up to 10 matching paragraph-level snippets (case-insensitive). Each result includes the section name and a text snippet (≤500 chars).

Defaults to the latest version. Call list_doc_versions(package) first if the user asks about a specific older version.

Args: package: Package name as returned by list_packages(). query: Free-text search query. version: Docs version slug (default: 'latest'). Use list_doc_versions() to discover available versions.

ParametersJSON Schema

Name	Required	Default
`query`	Yes
`package`	Yes
`version`	No	latest

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses that missing pages are fetched live and cached before searching, returns up to 10 case-insensitive paragraph-level snippets with section names and text ≤500 chars, and defaults to latest version. It does not mention rate limits or auth, but the caching and search behavior are well described. No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, with each sentence adding value. It front-loads the core purpose, then adds caching and output details, finally listing parameters in an Args block. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters, no annotations, and an output schema, the description covers all necessary aspects: purpose, caching behavior, output format (up to 10 snippets with section name and snippet ≤500 chars), and parameter semantics. The agent can correctly invoke this tool without further clarification.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description adds essential meaning: package is 'Package name as returned by list_packages()', query is 'Free-text search query', version is 'Docs version slug (default: "latest")' with guidance to use list_doc_versions() to discover versions. This fully compensates for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool searches package documentation for a query string, with specific details about caching and return format. It distinguishes itself from sibling tools like get_doc_section or fetch_latest_docs by focusing on search across documentation, not fetching a single section or full docs. The verb 'search' and resource 'package documentation' are explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description advises to call list_doc_versions(package) first if the user asks about a specific older version, providing clear context for when to use this tool versus list_doc_versions. However, it does not explicitly state when to avoid this tool or compare it to other search or fetch tools among siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_sourceA

Search the GitHub source code of a package for a query string.

Uses the GitHub code search API to find files containing the query. Returns up to 10 results with the file name, path, and GitHub URL.

Requires the GITHUB_TOKEN environment variable for best results (5000 req/hr authenticated vs 60/hr unauthenticated).

Args: package: Package name as returned by list_packages(). query: Search string (e.g. function name, class name, keyword).

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes
`package`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses behavior: uses GitHub API, returns up to 10 results with file name, path, URL. Notes authentication requirements and rate limits. Lacks detail on error handling or edge cases, but is adequate given no annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Reasonably concise with a clear structure: main description followed by argument explanations. No extraneous information, though could be slightly more streamlined.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, parameters, output format, and authentication. Given the tool has only 2 parameters and no annotations, the description is largely complete. Missing error conditions or version scope, but acceptable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has no descriptions (0% coverage). The description adds meaning: 'package' is a package name from list_packages(), 'query' is a search string example. Provides helpful context beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states it searches GitHub source code of a package for a query string using the GitHub Code Search API. It specifies the verb 'search' and resource 'source code of a package', and distinguishes from sibling tools like search_docs and get_function_source.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear context: requires GITHUB_TOKEN, rate limits (5000 vs 60 req/hr). However, does not explicitly state when to use this versus alternative sibling tools like search_docs or get_function_source, though the purpose differentiation is implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.3/5.0

Disambiguation4/5

Most tools have distinct purposes, but fetch_latest_docs and get_doc_section overlap in retrieving documentation sections, with nuanced differences in caching behavior. The descriptions help disambiguate but some confusion may remain.

Naming Consistency5/5

All tool names follow a consistent verb_noun snake_case pattern (e.g., fetch_latest_docs, get_package_info, search_source), making them predictable and easy to understand.

Tool Count5/5

With 11 tools, the set is well-scoped for the server's purpose of managing Python documentation and source code. Each tool serves a clear function without unnecessary bloat.

Completeness4/5

The tool set covers the main workflows: listing packages, retrieving documentation and source code, searching, and version management. Minor gaps like a missing 'get_docs_homepage' tool are mitigated by fetch_latest_docs's behavior.

Maintenance

ActivitySlowing

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

gread A
io.github.NitroRCr
An MCP server that gives your AI access to the source code and docs of all public github repos
Version Control Code Analysis Documentation Access
5361
mcp
dev.augments
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
Developer Tools Documentation Access
2128
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
ContextStream
io.contextstream
Persistent memory and cross-session learning for AI coding assistants (hosted remote MCP).
Knowledge & Memory Developer Tools
239

Related MCP Servers

CodeGraphMCPServer
Code Analysis RAG Systems Developer Tools
nahisaho
A
license
Not graded
quality
D
maintenance
A lightweight, zero-configuration MCP server for source code analysis with GraphRAG capabilities, enabling structural understanding and efficient code completion from MCP-compatible AI tools.
Updated 9 months ago (2025-12-11 12:55 UTC)
12
MIT
Context7 MCP Server
Developer Tools Code Analysis AI & Machine Learning
Mapileon2
F
license
Not graded
quality
D
maintenance
Enables LLM-powered code analysis, generation, debugging, and context management through MCP integration with IDEs like Cursor and Claude Desktop.
Updated a year ago (2025-08-20 20:45 UTC)
GreenCodeMCP
Developer Tools Code Analysis
DaoudiAmir
A
license
Not graded
quality
B
maintenance
An MCP server that detects energy anti-patterns in Python code, retrieves optimization examples, suggests refactoring, validates correctness, and benchmarks resource gains, integrating with VS Code, Cursor, and Windsurf.
Updated 2 months ago (2026-07-15 10:13 UTC)
MIT
GitHitsofficial
Developer Tools Documentation Access Search
githits-com
A
license
Not graded
quality
A
maintenance
Enables AI coding agents to search and access open-source code, documentation, and package information via a local MCP server.
Updated 9 hours ago (2026-09-01 19:25 UTC)
3,790
91
Apache 2.0

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/JonasKlimt/ie_mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

ie_mcp

Why?

Example questions

Prerequisites

Setup

1. Clone the repo

2. Connect to your AI client

1st Option: Use the mcp server from within this clonded (which then becomes your local) repository

2nd Option: Use the mcp server in your project

3. Point the server at the right Python environment

GitHub token (optional)

How the server works

Brightway ecosystem

Meta-packages

Brightway 2.5 core components

Additional brightway-lca packages

Additional packages

LCA tools

Material flow analysis (MFA)

Environmentally extended input output analysis

Adding a new package

License

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

GitHitsofficial

Latest Blog Posts

MCP directory API