consult_the_council

Instructions

Implementation Reference

• elrond_mcp/server.py:25-65 (handler)

  Primary MCP tool handler for 'consult_the_council', performs input validation, logging, creates CritiqueRequest, and delegates to process_proposal for core logic execution.

  @app.tool()
  async def consult_the_council(proposal: str) -> ThinkingAugmentationResult:
      """
      Analyze a proposal using hierarchical LLM critique and synthesis.
  
      This tool runs three specialized critique agents (positive, neutral, negative)
      in parallel to analyze the proposal, then synthesizes their perspectives
      into a comprehensive analysis with recommendations.
  
      Args:
          proposal: Markdown-formatted proposal outlining the salient points
                   of the solution to be analyzed
  
      Returns:
          Complete analysis including all critiques and synthesis with
          consensus view, recommendations, and next steps
      """
      try:
          logger.info("Received thinking augmentation request")
  
          # Validate input
          if not proposal.strip():
              raise ValueError("Proposal cannot be empty")
  
          if len(proposal.strip()) < 10:
              raise ValueError("Proposal must be at least 10 characters long")
  
          # Create request object and process
          request = CritiqueRequest(proposal=proposal)
          result = await process_proposal(request)
  
          logger.info("Thinking augmentation completed successfully")
          return result
  
      except ValueError as e:
          logger.error(f"Validation error: {e}")
          raise
      except Exception as e:
          logger.error(f"Error in thinking augmentation: {e}")
          raise RuntimeError(f"Failed to process proposal: {str(e)}") from e

• elrond_mcp/server.py:25-25 (registration)

  Registration of the 'consult_the_council' tool using FastMCP's @app.tool() decorator.

  @app.tool()

• elrond_mcp/models.py:16-24 (schema)

  Pydantic schema for the input request used internally by the tool handler (proposal: str with validation).

  class CritiqueRequest(BaseModel):
      """Request model for critique analysis."""
  
      proposal: str = Field(
          ...,
          description="Markdown-formatted proposal outlining the salient points of the "
          "solution",
          min_length=10,
      )

• elrond_mcp/models.py:139-161 (schema)

  Pydantic schema defining the structured output returned by the tool, including critiques, synthesis, and metadata.

  class ThinkingAugmentationResult(BaseModel):
      """Complete result from the thinking augmentation process."""
  
      original_proposal: str = Field(
          ..., description="The original proposal that was analyzed"
      )
  
      critiques: list[CritiqueResponse] = Field(
          ...,
          description="All critique responses (positive, neutral, negative)",
          min_length=3,
          max_length=3,
      )
  
      synthesis: SynthesisResponse = Field(
          ..., description="Final synthesis of all perspectives"
      )
  
      processing_metadata: dict = Field(
          default_factory=dict,
          description="Metadata about the processing (timestamps, model versions, etc.)",
      )

• elrond_mcp/agents.py:221-275 (helper)

  Core helper function implementing the thinking augmentation pipeline: creates critique agents, runs parallel analyses, synthesizes results, and constructs the final output.

  async def process_proposal(request: CritiqueRequest) -> ThinkingAugmentationResult:
      """Process a proposal through the complete thinking augmentation pipeline."""
      start_time = datetime.now(UTC)
  
      try:
          logger.info("Starting thinking augmentation process")
  
          # Create agents for this processing request
          positive_agent = CritiqueAgent("positive")
          neutral_agent = CritiqueAgent("neutral")
          negative_agent = CritiqueAgent("negative")
          synthesis_agent = SynthesisAgent()
  
          # Run all critiques in parallel
          critique_tasks = [
              positive_agent.analyze_proposal(request.proposal),
              neutral_agent.analyze_proposal(request.proposal),
              negative_agent.analyze_proposal(request.proposal),
          ]
  
          logger.info("Running parallel critiques")
          critiques = await asyncio.gather(*critique_tasks)
  
          logger.info("Critiques completed, starting synthesis")
  
          # Synthesize all critiques
          synthesis = await synthesis_agent.synthesize_critiques(
              request.proposal, critiques
          )
  
          end_time = datetime.now(UTC)
          processing_time = (end_time - start_time).total_seconds()
  
          logger.info(f"Thinking augmentation completed in {processing_time:.2f} seconds")
  
          # Create final result
          result = ThinkingAugmentationResult(
              original_proposal=request.proposal,
              critiques=critiques,
              synthesis=synthesis,
              processing_metadata={
                  "start_time": start_time.isoformat(),
                  "end_time": end_time.isoformat(),
                  "processing_time_seconds": processing_time,
                  "critique_model": "gemini-2.5-flash",
                  "synthesis_model": "gemini-2.5-pro",
                  "num_critiques": len(critiques),
              },
          )
  
          return result
  
      except Exception as e:
          logger.error(f"Error in thinking augmentation process: {e}")
          raise