Skip to main content
Glama
ChronulusAI

Chronulus MCP Server

Official

create_chronulus_session

Create a forecasting session by defining a situation and task to generate predictions for specific use cases using Chronulus AI.

Instructions

A tool that creates a new Chronulus Session and returns a session_id

When to use this tool:

  • Use this tool when a user has requested a forecast or prediction for a new use case

  • Before calling this tool make sure you have enough information to write a well-defined situation and task. You might need to ask clarifying questions in order to get this from the user.

  • The same session_id can be reused as long as the situation and task remain the same

  • If user wants to forecast a different use case, create a new session and then use that

How to use this tool:

  • To create a session, you need to provide a situation and task that describe the forecasting use case

  • If the user has not provided enough detail for you to decompose the use case into a situation (broad or background context) and task (specific requirements for the forecast), ask them to elaborate since more detail will result in a better / more accurate forecast.

  • Once created, this will generate a unique session_id that can be used to when calling other tools about this use case.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
nameYesA short descriptive name for the use case defined in the session.
situationYesThe broader context for the use case
taskYesSpecific details on the forecasting or prediction task.

Implementation Reference

  • The main handler function for the 'create_chronulus_session' tool. It creates a new Chronulus Session using the provided name, situation, and task parameters, handles errors, and returns the session ID.
    async def create_chronulus_session(
            name: Annotated[str, Field(description="A short descriptive name for the use case defined in the session.")],
            situation: Annotated[str, Field(description="The broader context for the use case")],
            task: Annotated[str, Field(description="Specific details on the forecasting or prediction task.")],
            ctx: Context
    ) -> str:
        """Creates a new Chronulus Session
    
        A Chronulus Session allows you to use Chronulus Agents. To create a session, you need to provide a situation
        and task. Once created, this will generate a unique session id that can be used to when calling the agents.
    
        Args:
            name (str): A short descriptive name for the use case defined in the session.
            situation (str): The broader context for the use case.
            task (str): The specific prediction task.
    
    
        Returns:
            str: The session ID.
        """
    
        try:
            chronulus_session = Session(
                name=name,
                situation=situation,
                task=task,
                verbose=False,
            )
    
        except Exception as e:
            error_message = f"Failed to create chronulus session with the following error: \n\n{e}"
            _ = await ctx.error(message=error_message)
            return error_message
    
        return chronulus_session.session_id
  • Registers the 'create_chronulus_session' tool with the MCP server, including its detailed description.
    CREATE_SESSION_DESCRIPTION = """
    A tool that creates a new Chronulus Session and returns a session_id
    
    When to use this tool:
    - Use this tool when a user has requested a forecast or prediction for a new use case
    - Before calling this tool make sure you have enough information to write a well-defined situation and task. You might
    need to ask clarifying questions in order to get this from the user.
    - The same session_id can be reused as long as the situation and task remain the same
    - If user wants to forecast a different use case, create a new session and then use that
    
    How to use this tool:
    - To create a session, you need to provide a situation and task that describe the forecasting use case 
    - If the user has not provided enough detail for you to decompose the use case into a 
        situation (broad or background context) and task (specific requirements for the forecast), 
        ask them to elaborate since more detail will result in a better / more accurate forecast.
    - Once created, this will generate a unique session_id that can be used to when calling other tools about this use case.
    """
    
    # session tools
    mcp.add_tool(create_chronulus_session, description=CREATE_SESSION_DESCRIPTION)
  • Imports the create_chronulus_session function from session.py for use in registration.
    from .session import create_chronulus_session, get_risk_assessment_scorecard
Behavior4/5

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

With no annotations provided, the description carries full burden and does well: it discloses that the tool creates a session (implying a write operation), returns a unique session_id, and that sessions are reusable under certain conditions. It could improve by mentioning potential errors, rate limits, or authentication needs, but covers key behavioral aspects like creation and reuse.

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?

The description is well-structured with clear sections ('When to use this tool', 'How to use this tool') and front-loaded purpose. It could be more concise by reducing repetition (e.g., 'ask clarifying questions' appears twice) and trimming explanatory details that might be inferred, but overall it's efficient and organized.

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 creation tool with no annotations and no output schema, the description provides good context: it explains the purpose, usage guidelines, behavioral traits (creation, session_id return, reuse), and parameter expectations. It could be more complete by detailing output format or error handling, but covers most essentials given the complexity.

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 schema already documents all three parameters (name, situation, task). The description adds some context by explaining that situation is 'broad or background context' and task is 'specific requirements for the forecast', but this largely reiterates schema descriptions. Baseline 3 is appropriate as schema does heavy lifting.

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 explicitly states the tool 'creates a new Chronulus Session and returns a session_id', providing a specific verb ('creates') and resource ('Chronulus Session'). It distinguishes this from sibling tools like 'create_forecasting_agent_and_get_forecast' by focusing on session creation rather than forecasting or prediction generation directly.

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 includes a dedicated 'When to use this tool' section with explicit guidance: use for new forecasting/prediction use cases, ensure sufficient information first, reuse session_id for same situation/task, and create new sessions for different use cases. It also implies alternatives by noting session reuse and distinguishing from other tools that might handle forecasting directly.

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

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/ChronulusAI/chronulus-mcp'

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