> ## Documentation Index
> Fetch the complete documentation index at: https://docs.messari.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Chat Completion - Messari Format

> The MessariAI API's Chat Completion endpoint is used for generating contextual crypto responses using Messari's knowledge graph and specialized tools.

If you'd like to play around with the responses feel free to try on the [Messari web-app](https://messari.io/copilot), it uses the same underlying endpoint implementation.

The chat completion endpoint leverages a graph architecture with agents to:

* Access Messari's real-time quantitative (compute) dataset which includes but is not limited to: Market data, Asset metrics, Fundraising, Token unlocks

* Access Messari's qualitative (search) dataset which includes but is not limited to: News, Blogs, Youtube transcriptions, RSS-feeds, Twitter, Webcrawl documents, Proprietary datasets of: Research, Quarterlies, Diligence Reports

* Generate market insights and analysis

* Process natural language queries about crypto assets, protocols and projects

For a more interactive experience trying out the API, [here is our Replit in Typescript](https://replit.com/@malcolm22/MessariAI-API-Examples#index.ts). Simply populate the `API_KEY` field with your Enterprise API key generated in the [Messari Account > API page](https://messari.io/account/api) of our webapp and you're off!

### Request Params

#### verbosity

The `verbosity` parameter controls the level of detail in the model's response. When set to `"verbose"`, the model provides more comprehensive and detailed explanations, including additional context, examples, and supporting information. Other possible values might include `"balanced"` or `"succinct"` for shorter responses.

Example usage:

```json theme={null}
{
  "verbosity": "verbose"
}
```

#### response\_format

The `response_format` parameter specifies the desired formatting style for the model's response. When set to `"markdown"`, the output will be formatted using Markdown syntax, allowing for structured text with headings, lists, code blocks, and other formatting elements. Other common option might include `"text"`.

**Example usage:**

```json theme={null}
{
  "response_format": "markdown"
}
```

#### inline\_citations

The `inline_citations` parameter determines whether the response metadata should include citations within its response text. When set to `true`, the model will reference sources directly in the text where information is being drawn from. This is particularly useful for academic, research, or factual content where attribution is important.

**Example usage:**

```json theme={null}
{
  "inline_citations": true
}
```

#### stream

The `stream` parameter controls whether the API response is delivered as a complete response or as a stream of partial responses. When set to `false`, the API will wait until the entire response is generated and then deliver it in one piece. When set to `true`, the API would begin sending partial responses as they are generated, useful for implementing real-time typing effects or processing responses incrementally.

**Example usage:**

```json theme={null}
{
  "stream": false
}
```

#### generate\_related\_questions

The `generate_related_questions` parameter determines whether the response metadata should include AI-generated related questions to the user query. This feature is useful for receiving follow up questions as part of the API response payload to prompt the user with potential next questions.

Note: A maximum of 5 is allowed.

**Example usage:**

```json theme={null}
{
  "generate_related_questions": 2
}
```


## OpenAPI

````yaml POST /ai/v1/chat/completions
openapi: 3.0.0
info:
  description: OpenAPI specification for the entire Messari API
  title: Messari API - Ai V1
  version: 1.0.0
servers:
  - description: Messari API
    url: https://api.messari.io
security: []
paths:
  /ai/v1/chat/completions:
    post:
      summary: Generate chat completions with Messari AI
      description: >-
        Processes a conversation and returns an AI-generated response with
        Messari's standard format. Consumes 5 credits per request.
      operationId: postChatCompletion
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ChatCompletionRequest'
            example:
              messages:
                - role: user
                  content: What is Solana?
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  data:
                    $ref: '#/components/schemas/ChatCompletionResponse'
                  error:
                    type: string
                  metadata:
                    $ref: '#/components/schemas/ChatCompletionResponseMetadata'
                required:
                  - data
                type: object
              example:
                error: null
                data:
                  messages:
                    - role: assistant
                      content: >-
                        # Solana Overview


                        Solana is a Layer-1 blockchain network optimized for
                        **scalability** and designed to provide infrastructure
                        for decentralized applications (dapps). Its primary goal
                        is to offer a platform where developers can build
                        applications without encountering common performance
                        bottlenecks, such as high transaction fees and
                        throughput limitations.


                        ## Key Features and Design Goals


                        Solana's design emphasizes high performance and
                        efficiency, aiming to minimize constraints typically
                        faced by developers:


                        *   **High Throughput:** The network is designed to
                        handle a high volume of transactions, with the capacity
                        to process up to 710,000 transactions per second (TPS)
                        at peak load.

                        *   **Low Costs:** It aims for low transaction costs and
                        sub-second settlement times.

                        *   **Scalability:** Solana achieves scalability without
                        relying on second-layer or off-chain technologies.

                        *   **Smart Contract Support:** It supports all
                        LLVM-compatible smart contract languages, which is a
                        collection of modular compiler and toolchain
                        technologies.


                        The network utilizes a Proof of Stake (PoS) consensus
                        mechanism combined with a unique component called Tower
                        Consensus to achieve its high throughput.


                        ## The SOL Token


                        The native token of the Solana network is **SOL**, which
                        was launched alongside the Mainnet Beta in March 2020.
                        SOL serves several essential functions within the
                        ecosystem:


                        *   **Transaction Fees:** Users pay fees in SOL for
                        sending transactions and executing smart contracts.
                        These fees include a static base fee per signature and a
                        variable fee based on the computational resources used.
                        Transactions can also include an optional
                        "prioritization fee" for faster processing.

                        *   **Staking:** SOL is used for staking to secure the
                        network.

                        *   **Governance:** The token is used for on-chain
                        governance.


                        ## Ecosystem and Applications


                        Solana provides a robust environment for various
                        decentralized applications and services:


                        *   **Decentralized Finance (DeFi):** Projects like
                        Phoenix, a spot limit order book implementation by
                        Ellipsis Labs, are built on Solana to create efficient
                        and scalable DeFi infrastructure.

                        *   **Payments:** Solana Pay is a protocol for payments
                        on Solana, designed to build new payment and commerce
                        rails for merchants that utilize the blockchain for
                        secure transactions without intermediaries.

                        *   **Gaming and NFTs:** Solana offers tools like
                        GameShift, an API that streamlines integration with Web3
                        features for development studios, handling interactions
                        with Solana for self-custodied game assets and
                        abstracted transaction fees.

                        *   **Customer Engagement:** Platforms like Bond utilize
                        Solana to drive customer engagement for brands through
                        digital collectibles, luxury-good authentication,
                        verified digital identities, and loyalty programs.


                        ## Company Background


                        Solana was founded in 2017 and is headquartered in San
                        Francisco, CA. It is a private company that has raised a
                        total of $335 million in funding.
                metadata:
                  status: Completed
                  trace_id: 63c56f80-4ac7-4e24-8fb7-a896e8bc5100
                  cited_sources:
                    - domain: asset_profile
                      url: https://messari.io/asset/solana
                    - domain: diligence
                      title: 'Diligence Report: General Information'
                      url: >-
                        https://messari.io/asset/solana/diligence-report#general_information
                    - domain: diligence
                      title: 'Diligence Report: Token Economics'
                      url: >-
                        https://messari.io/asset/solana/diligence-report#token_usage_and_economics
                    - domain: research_image
                      title: Solana Ecosystem Overview
                      url: >-
                        https://cdn.sanity.io/images/2bt0j8lu/production/10299763330e60bae0a812764da7cbd1c3e3d153-1940x976.png?w=800
                    - domain: research_image
                      title: 'Solana Deep Dive: Reframing The Narrative'
                      url: >-
                        https://cdn.sanity.io/images/2bt0j8lu/production/7a725362c19ddb5f7b089a68dcc13d416fa6726d-2782x1508.png?w=800
                    - domain: news
                      title: >-
                        What Is Solana? A Scalable, Decentralized Network for
                        Dapps
                      url: >-
                        https://decrypt.co/resources/what-is-solana-a-scalable-decentralized-network-for-dapps
                    - domain: webcrawl
                      url: https://www.kraken.com/prices/solana
                    - domain: webcrawl
                      title: >-
                        Solana Company Profile 2025: Valuation, Funding &
                        Investors | PitchBook
                      url: https://pitchbook.com/profiles/company/227820-52
                    - domain: webcrawl
                      title: >-
                        Solana - Products, Competitors, Financials, Employees,
                        Headquarters Locations
                      url: https://www.cbinsights.com/company/solana-labs
                    - domain: webcrawl
                      title: >-
                        There are no bad questions about... blockchain payments
                        | Solana
                      url: https://solana.com/learn/payments
          description: Default response
        '400':
          content:
            application/json:
              schema:
                properties:
                  data: {}
                  error:
                    type: string
                required:
                  - data
                type: object
          description: Bad Request
        '401':
          content:
            application/json:
              schema:
                properties:
                  data: {}
                  error:
                    type: string
                required:
                  - data
                type: object
          description: Unauthorized
        '500':
          content:
            application/json:
              schema:
                properties:
                  data: {}
                  error:
                    type: string
                required:
                  - data
                type: object
          description: Internal Server Error
      security:
        - apiKey: []
components:
  schemas:
    ChatCompletionRequest:
      properties:
        allow_clarification_query:
          description: Whether the AI can ask for clarification when the query is ambiguous
          type: boolean
          default: true
        generate_related_questions:
          description: Adds AI generated related questions to use as follow up questions
          format: int64
          type: integer
          default: 2
        inline_citations:
          description: Adds inline citation document references in the payload metadata
          type: boolean
          default: true
        messages:
          description: Array of messages in the conversation history
          items:
            $ref: '#/components/schemas/ChatCompletionMessage'
          type: array
        response_format:
          description: >-
            Text format for the response. Values accepted are 'markdown' and
            'plaintext'.
          type: string
          default: markdown
        stream:
          description: Stream the response through the API
          type: boolean
          default: false
        verbosity:
          description: >-
            Controls the length and detail level of the AI-generated response.
            Values accepted are 'succinct', 'balanced', and 'verbose'.
          type: string
          default: balanced
      required:
        - messages
      type: object
    ChatCompletionResponse:
      properties:
        messages:
          description: Array of response messages from the assistant
          items:
            $ref: '#/components/schemas/ChatCompletionResponseMessage'
          type: array
      required:
        - messages
      type: object
    ChatCompletionResponseMetadata:
      properties:
        charts:
          description: Chart data referenced in the response
          items:
            $ref: '#/components/schemas/ChartSource'
          type: array
        cited_sources:
          description: Sources cited in the response content
          items:
            $ref: '#/components/schemas/StandardSource'
          type: array
        related_questions:
          description: Follow-up questions related to the original query
          items:
            type: string
          type: array
        status:
          description: Current status of the completion request
          type: string
        trace_id:
          description: Unique identifier for tracing the request
          format: byte
          type: string
      required:
        - status
        - trace_id
      type: object
    ChatCompletionMessage:
      type: object
      properties:
        role:
          type: string
          enum:
            - user
            - assistant
            - system
          default: user
          description: The role of the message author
        content:
          type: string
          default: What is Solana?
          description: The content of the message
      required:
        - role
        - content
    ChatCompletionResponseMessage:
      type: object
      description: Schema for ChatCompletionResponseMessage
      properties: {}
      additionalProperties: true
    ChartSource:
      type: object
      description: Schema for ChartSource
      properties: {}
      additionalProperties: true
    StandardSource:
      type: object
      description: Schema for StandardSource
      properties: {}
      additionalProperties: true
  securitySchemes:
    apiKey:
      in: header
      name: X-Messari-API-Key
      type: apiKey

````