Chronulus MCP Server

Instructions

Implementation Reference

• src/chronulus_mcp/agent/predictor.py:95-134 (handler)

  The async handler function implementing the core logic of the tool: loads a pre-existing BinaryPredictor agent by ID, processes input data into the agent's input type, queues a prediction request with the specified number of experts, retrieves the prediction set, and returns structured results including expert opinions and probability.

  async def reuse_prediction_agent_and_get_prediction(
          agent_id: Annotated[str, Field(description="The agent_id for the forecasting or prediction use case and previously defined input_data_model")],
          input_data: Annotated[Dict[str, Union[str, dict, List[dict]]], Field(
              description="The forecast inputs that you will pass to the chronulus agent to make the prediction. The keys of the dict should correspond to the InputField name you provided in input_fields.")],
          num_experts: Annotated[int, Field(description="The number of experts to consult when forming consensus")],
  
  ) -> Union[str, Dict[str, Union[dict, str]]]:
      """Queues and retrieves a binary event prediction from Chronulus with a previously created agent_id
  
      This tool provides a prediction input to a previous created Chronulus BinaryPredictor agent and returns the
      prediction data and text explanations from each of the experts consulted by the agent.
  
      Args:
          agent_id (str): The agent_id for the forecasting or prediction use case and previously defined input_data_model
          input_data (Dict[str, Union[str, dict, List[dict]]]): The forecast inputs that you will pass to the chronulus agent to make the prediction. The keys of the dict should correspond to the InputField name you provided in input_fields.
          num_experts (int): The number of experts to consult when forming consensus.
  
      Returns:
          Union[str, Dict[str, Union[dict, str]]]: a dictionary with prediction data, a text explanation of the predictions, agent_id, and probability estimate.
      """
  
      agent = BinaryPredictor.load_from_saved_estimator(estimator_id=agent_id, verbose=False)
      item = agent.input_type(**input_data)
  
      try:
          req = agent.queue(item, num_experts=num_experts, note_length=(5,10))
      except Exception as e:
          return f"""Error at nf_agent: {str(e)}"""
  
      try:
          prediction_set = agent.get_request_predictions(req.request_id)
          return {
              "agent_id": agent.estimator_id,
              "request_id": req.request_id,
              "beta_params": prediction_set.beta_params,
              'expert_opinions': [p.text for p in prediction_set],
              'probability': prediction_set.prob_a}
  
      except Exception as e:
          return f"""Error on prediction: {str(e)}"""

• src/chronulus_mcp/__init__.py:235-235 (registration)

  Registers the 'reuse_prediction_agent_and_get_prediction' tool with the FastMCP server instance, associating it with a detailed description string.

  mcp.add_tool(reuse_prediction_agent_and_get_prediction, description=REUSE_AGENT_AND_GET_PREDICTION_DESCRIPTION)

• src/chronulus_mcp/agent/predictor.py:96-100 (schema)

  Pydantic schema definitions for the tool's input parameters using Annotated types with Field descriptions, defining agent_id (str), input_data (Dict), and num_experts (int). The function docstring also provides additional schema details including return type.

  agent_id: Annotated[str, Field(description="The agent_id for the forecasting or prediction use case and previously defined input_data_model")],
  input_data: Annotated[Dict[str, Union[str, dict, List[dict]]], Field(
      description="The forecast inputs that you will pass to the chronulus agent to make the prediction. The keys of the dict should correspond to the InputField name you provided in input_fields.")],
  num_experts: Annotated[int, Field(description="The number of experts to consult when forming consensus")],

• src/chronulus_mcp/__init__.py:7-7 (registration)

  Imports the handler function from predictor.py into the __init__.py module for use in tool registration.

  from chronulus_mcp.agent.predictor import create_prediction_agent_and_get_predictions, reuse_prediction_agent_and_get_prediction

• src/chronulus_mcp/__init__.py:184-215 (helper)

  Detailed description string for the tool, used in registration, providing usage instructions, when to use, and input guidelines including file types.

  REUSE_AGENT_AND_GET_PREDICTION_DESCRIPTION = f"""
  This tool provides prediction input data to a previously created Chronulus BinaryPredictor agent and returns the 
  consensus a prediction from a panel of experts along with their individual estimates and text explanations. The agent 
  also returns the alpha and beta parameters for a Beta distribution that allows you to estimate the confidence interval 
  of its consensus probability estimate.
  
  When to use this tool:
  - Use this tool to request a prediction from a Chronulus prediction agent that you have already created and when your 
  input data model is unchanged
  - Use this tool to request a probability estimate from an existing prediction agent in a situation when there is a binary outcome
  - This tool is specifically made to estimate the probability of an event occurring and not occurring and does not 
  require historical data
  
  How to use this tool:
  - First, make sure you have a session_id for the prediction use case.
  - Next, think about the features / characteristics most suitable for producing the requested prediction and then 
  create an input_data_model that corresponds to the input_data you will provide for the thing or event being predicted.
  {FILE_TYPE_INSTRUCTIONS}
  - Finally, provide the number of experts to consult. The minimum and default number is 2, but users may request up to 30
  30 opinions in situations where reproducibility and risk sensitively is of the utmost importance. In most cases, 2 to 5 
  experts is sufficient. 
  
  How to use this tool:
  - First, make sure you have an agent_id for the prediction agent. The agent is already attached to the correct session. 
  So you do not need to provide a session_id.
  - Next, reference the input data model that you previously used with the agent and create new input data for the item 
  being predicted that aligns with the previously specified input data model
  {FILE_TYPE_INSTRUCTIONS}
  - Finally, provide the number of experts to consult. The minimum and default number is 2, but users may request up to 30
  30 opinions in situations where reproducibility and risk sensitively is of the utmost importance. In most cases, 2 to 5 
  experts is sufficient. 
  """