Skip to main content
Glama
noopstudios

Interactive Feedback MCP

by noopstudios

interactive_feedback

Enable real-time human-in-the-loop feedback for AI-assisted development. Submit project directory and summary to request interactive review, improving collaboration and accuracy in AI-generated outputs.

Instructions

Request interactive feedback for a given project directory and summary

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
project_directoryYesFull path to the project directory
summaryYesShort, one-line summary of the changes

Implementation Reference

  • server.py:64-71 (handler)
    The handler function decorated with @mcp.tool(), which registers the tool and executes the logic by launching the feedback UI subprocess and returning the collected feedback.
    @mcp.tool()
    def interactive_feedback(
        project_directory: Annotated[str, Field(description="Full path to the project directory")],
        summary: Annotated[str, Field(description="Short, one-line summary of the changes")],
    ) -> Dict[str, str]:
        """Request interactive feedback for a given project directory and summary"""
        return launch_feedback_ui(first_line(project_directory), first_line(summary))
  • TypedDict defining the output schema of the tool, including the 'interactive_feedback' field (note: used as 'logs' in code).
    class FeedbackResult(TypedDict):
        command_logs: str
        interactive_feedback: str
  • Helper function that launches the feedback_ui.py subprocess, handles temporary file for JSON output, and returns the feedback result dictionary.
    def launch_feedback_ui(project_directory: str, summary: str) -> dict[str, str]:
        # Create a temporary file for the feedback result
        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as tmp:
            output_file = tmp.name
    
        try:
            # Get the path to feedback_ui.py relative to this script
            script_dir = os.path.dirname(os.path.abspath(__file__))
            feedback_ui_path = os.path.join(script_dir, "feedback_ui.py")
    
            # Run feedback_ui.py as a separate process
            # NOTE: There appears to be a bug in uv, so we need
            # to pass a bunch of special flags to make this work
            args = [
                sys.executable,
                "-u",
                feedback_ui_path,
                "--project-directory", project_directory,
                "--prompt", summary,
                "--output-file", output_file
            ]
            result = subprocess.run(
                args,
                check=False,
                shell=False,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.DEVNULL,
                stdin=subprocess.DEVNULL,
                close_fds=True
            )
            if result.returncode != 0:
                raise Exception(f"Failed to launch feedback UI: {result.returncode}")
    
            # Read the result from the temporary file
            with open(output_file, 'r') as f:
                result = json.load(f)
            os.unlink(output_file)
            return result
        except Exception as e:
            if os.path.exists(output_file):
                os.unlink(output_file)
            raise e
  • Utility helper to extract the first line from project_directory and summary paths.
    def first_line(text: str) -> str:
        return text.split("\n")[0].strip()
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure but only states the basic action. It lacks details on what 'interactive feedback' entails (e.g., format, user interaction, permissions required, or potential side effects), leaving significant gaps in understanding how the tool behaves.

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 with no wasted words, effectively front-loading the core purpose. It is appropriately sized for the tool's complexity and avoids unnecessary elaboration.

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

Completeness2/5

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

Given the lack of annotations and output schema, the description is incomplete. It fails to explain what 'interactive feedback' means in practice, such as the response format or any behavioral traits, leaving the agent with insufficient context to use the tool effectively.

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

Parameters3/5

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

Schema description coverage is 100%, so the input schema fully documents both parameters. The description adds no additional meaning beyond implying the parameters are used together for feedback, which aligns with the schema. This meets the baseline for high schema coverage.

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

Purpose4/5

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

The description clearly states the action ('Request interactive feedback') and the target resources ('for a given project directory and summary'), making the purpose immediately understandable. However, without sibling tools for comparison, it cannot demonstrate differentiation, so it doesn't reach the highest score.

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

Usage Guidelines2/5

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, such as specific scenarios, prerequisites, or alternatives. It simply states what the tool does without context for its application.

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

Install Server

Other Tools

Related Tools

Latest Blog Posts

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/noopstudios/interactive-feedback-mcp'

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