A conversational time series forecasting assistant with Amazon Bedrock and LibreChat

Flavia Giammarino — Fri, 27 Mar 2026 20:32:54 +0000

Dashboards and reports remain the default interface for most forecasting systems, but they limit users to prespecified queries and views. In this post, we walk through the implementation of a conversational time series forecasting assistant built with ClickHouse, Amazon Bedrock, and LibreChat. This approach enables users to explore time series data interactively and adjust forecast parameters — such as quantile levels and prediction horizons — through natural language.

The solution is built around the Model Context Protocol (MCP), which defines a standard interface for connecting language models to external tools and services. Three MCP servers handle the core functionality: the official ClickHouse MCP server for data retrieval, a custom forecasting server wrapping Chronos - a time series foundation model developed by Amazon - on Amazon Bedrock, and a custom data visualization server for interactive Plotly charts. Claude Sonnet 4.6 on Amazon Bedrock orchestrates the tool calls.

The video below shows the assistant handling a retail sales forecasting scenario: exploring the available product sales time series, plotting a product's hourly sales over the most recent week, forecasting the next 48 hours, and repeating the analysis for additional products, with all results shown in a single combined chart.

Architecture

The three MCP servers are configured as Docker services in docker-compose.override.yml, alongside the LibreChat api service. The ClickHouse server uses the official mcp/clickhouse image; the forecasting and visualization servers are built from custom Docker images described below.

services:
  api:
    volumes:
      - ./librechat.yaml:/app/librechat.yaml
  mcp-clickhouse:
    image: mcp/clickhouse
    container_name: mcp-clickhouse
    ports:
      - 8001:8000
    extra_hosts:
      - "host.docker.internal:host-gateway"
    environment:
      - CLICKHOUSE_HOST=<CLICKHOUSE_HOST>
      - CLICKHOUSE_USER=<CLICKHOUSE_USER>
      - CLICKHOUSE_PASSWORD=<CLICKHOUSE_PASSWORD>
      - CLICKHOUSE_MCP_SERVER_TRANSPORT=sse
      - CLICKHOUSE_MCP_BIND_HOST=0.0.0.0
  chronos-forecasting:
    build:
      context: ./chronos-forecasting
    ports:
      - "8002:8002"
    environment:
      - AWS_DEFAULT_REGION=eu-west-1
      - AWS_ACCESS_KEY_ID=<AWS_ACCESS_KEY_ID>
      - AWS_SECRET_ACCESS_KEY=<AWS_SECRET_ACCESS_KEY>
  data-visualization:
    build:
      context: ./data-visualization
    ports:
      - "8003:8003"
      - "8004:8004"
    volumes:
      - ./plots:/plots

Note that the visualization server exposes two ports: 8003 for the MCP server (SSE transport) and 8004 for the HTTP file server that serves the generated HTML charts. The /plots directory is mounted as a volume so charts persist across container restarts.

The servers are registered in librechat.yaml using SSE transport:

mcpServers:
  clickhouse-playground:
    type: sse
    url: http://host.docker.internal:8001/sse
  chronos-forecasting:
    type: sse
    url: http://host.docker.internal:8002/sse
  data-visualization:
    type: sse
    url: http://host.docker.internal:8003/sse

The LibreChat modelSpecs object ties the model, the MCP servers, and the system prompt together into a named assistant configuration:

modelSpecs:
  list:
    - name: "forecasting-assistant"
      label: "Forecasting Assistant"
      default: true
      artifacts: true
      mcpServers:
        - "clickhouse-playground"
        - "chronos-forecasting"
        - "data-visualization"
      preset:
        endpoint: "bedrock"
        model: "eu.anthropic.claude-sonnet-4-6"
        region: "eu-west-1"
        promptPrefix: |
          You are a time series forecasting assistant.
          Do not alter the time frequency of the data unless the user explicitly requests it.
          To visualize data, always use the `visualize_data` tool. Never write code to generate plots.
          When visualizing multiple series, always pass them together to the `visualize_data` tool in a single call,
          as it generates subplots automatically.
          Always render the URL returned by the `visualize_data` tool as an artifact using this exact format:
          :::artifact{identifier="<IDENTIFIER>" type="text/html" title="<TITLE>"}
          \`\`\`
          <!DOCTYPE html>
          <html>
          <body>
            <iframe src="<URL>" width="100%" height="800px" frameborder="0"></iframe>
          </body>
          </html>
          \`\`\`
          :::
          Never return the raw URL and never ask the user to open the URL themselves.

The system prompt instructs the model to wrap chart URLs in LibreChat Artifacts format, so the LibreChat UI renders the Plotly chart directly rather than displaying a raw localhost URL.

Forecasting MCP Server

The forecasting server is built with FastMCP and exposes a single generate_forecasts tool. It invokes the Chronos endpoint deployed on Amazon Bedrock via boto3, passing the historical values as context along with the desired prediction length and quantile levels.

Since Chronos performs zero-shot forecasting without fine-tuning, the server works out of the box on any time series. For instructions on deploying Chronos on Amazon Bedrock, see this previous post.

server.py

import json
import boto3
from mcp.server.fastmcp import FastMCP

# Create the FastMCP server
mcp = FastMCP(
    name="chronos-forecasting",
    host="0.0.0.0",
    port=8002
)

# Register the tool with the FastMCP server
@mcp.tool()
def generate_forecasts(
    target: list[float],
    prediction_length: int,
    quantile_levels: list[float]
) -> dict:
    """
    Generate probabilistic time series forecasts using Chronos on Amazon Bedrock.

    Parameters:
    ===============================================================================
    target: list of float.
        The historical time series values used as context.

    prediction_length: int.
        The number of future time steps to predict.

    quantile_levels: list of float.
        The quantiles to be predicted at each future time step.

    Returns:
    ===============================================================================
    dict
        Dictionary with predicted mean and quantiles at each future time step.
    """
    # Create the Bedrock client
    bedrock_runtime_client = boto3.client("bedrock-runtime")

    # Invoke the Bedrock endpoint
    response = bedrock_runtime_client.invoke_model(
        modelId="<bedrock-endpoint-arn>",
        body=json.dumps({
            "inputs": [{
                "target": target
            }],
            "parameters": {
                "prediction_length": prediction_length,
                "quantile_levels": quantile_levels
            }
        })
    )

    # Extract the forecasts
    forecasts = json.loads(response["body"].read()).get("predictions")[0]

    # Return the forecasts
    return forecasts


# Run the FastMCP server with SSE transport
if __name__ == "__main__":
    mcp.run(transport="sse")

The server's requirements.txt and Dockerfile are reported below:

requirements.txt

mcp
boto3

Dockerfile

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY server.py .
CMD ["python", "server.py"]

Data Visualization MCP Server

The data visualization server is also built with FastMCP. It exposes a visualize_data tool that takes historical data and optional forecast outputs, builds a Plotly figure with one subplot per time series, saves it as a self-contained HTML file, and returns the URL. A lightweight HTTP server running in a background thread serves the /plots directory on port 8004.

Using a dedicated MCP server for data visualization — rather than having the model generate chart code directly — ensures consistent styling and reproducible outputs across sessions.

The tool input schema is designed to accept the raw output of ClickHouse queries directly, so the model does not need to reformat data between tool calls: