Conversational API

Create a chat API endpoint that handles streaming responses from the C1 model.

Install required dependencies

Install the necessary packages for your backend API:

npm

npm install openai @crayonai/stream

Create the message store

First, create a simple in-memory message store to manage conversation history. This in-memory store just stores the list of messages for a given threadId including messages that are not sent to the client like the tool call messages.

app/api/chat/messageStore.ts

import OpenAI from "openai";

export type DBMessage = OpenAI.Chat.ChatCompletionMessageParam & {
  id?: string;
};

const messagesStore: {
  [threadId: string]: DBMessage[];
} = {};

export const getMessageStore = (threadId: string) => {
  if (!messagesStore[threadId]) {
    messagesStore[threadId] = [];
  }
  const messageList = messagesStore[threadId];
  return {
    addMessage: (message: DBMessage) => {
      messageList.push(message);
    },
    getOpenAICompatibleMessageList: () => {
      return messageList.map((m) => {
        const message = { ...m };
        delete message.id;
        return message;
      });
    },
  };
};

from typing import Dict, List, Any

# Type alias for messages
DBMessage = Dict[str, Any]

messages_store: Dict[str, List[DBMessage]] = {}


class MessageStore:
    def __init__(self, thread_id: str):
        if thread_id not in messages_store:
            messages_store[thread_id] = []
        self.message_list = messages_store[thread_id]

    def add_message(self, message: DBMessage):
        self.message_list.append(message)

    def get_openai_compatible_message_list(self) -> List[Dict[str, Any]]:
        return [
            {k: v for k, v in msg.items() if k != "id"}
            for msg in self.message_list
        ]


def get_message_store(thread_id: str) -> MessageStore:
    return MessageStore(thread_id)

Create the chat endpoint

Create the main API endpoint that handles incoming chat requests with streaming:

app/api/chat/route.ts

import { NextRequest, NextResponse } from "next/server";
import OpenAI from "openai";
import { transformStream } from "@crayonai/stream";
import { DBMessage, getMessageStore } from "./messageStore";

export async function POST(req: NextRequest) {
  const { prompt, threadId, responseId } = (await req.json()) as {
    prompt: DBMessage;
    threadId: string;
    responseId: string;
  };

  // Initialize the OpenAI client
  const client = new OpenAI({
    baseURL: "https://api.thesys.dev/v1/embed/",
    apiKey: process.env.THESYS_API_KEY,
  });

  // Get message store and add user message
  const messageStore = getMessageStore(threadId);
  messageStore.addMessage(prompt);

  // Create streaming chat completion
  const llmStream = await client.chat.completions.create({
    model: "c1/anthropic/claude-sonnet-4/v-20251230",
    messages: messageStore.getOpenAICompatibleMessageList(),
    stream: true,
  });

  // Transform the response stream
  const responseStream = transformStream(
    llmStream,
    (chunk) => {
      return chunk.choices[0].delta.content;
    },
    {
      onEnd: ({ accumulated }) => {
        const message = accumulated.filter((message) => message).join("");
        messageStore.addMessage({
          role: "assistant",
          content: message,
          id: responseId,
        });
      },
    }
  ) as ReadableStream;

  // Return the streaming response
  return new NextResponse(responseStream, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache, no-transform",
      Connection: "keep-alive",
    },
  });
}

import os
from fastapi import FastAPI
from pydantic import BaseModel
from openai import OpenAI
from thesys_genui_sdk.fast_api import with_c1_response
from thesys_genui_sdk.context import write_content, get_assistant_message
from message_store import get_message_store, DBMessage

app = FastAPI()


class ChatRequest(BaseModel):
    prompt: DBMessage
    threadId: str
    responseId: str


@app.post("/api/chat")
@with_c1_response()
async def chat(request: ChatRequest):
    # Initialize the OpenAI client
    client = OpenAI(
        api_key=os.environ["THESYS_API_KEY"],
        base_url="https://api.thesys.dev/v1/embed",
    )

    # Get message store and add user message
    message_store = get_message_store(request.threadId)
    message_store.add_message(request.prompt)

    # Create streaming chat completion
    stream = client.chat.completions.create(
        model="c1/anthropic/claude-sonnet-4/v-20251230",
        messages=message_store.get_openai_compatible_message_list(),
        stream=True,
    )

    # Stream the response
    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            await write_content(content)

    # Get and store the assistant message
    assistant_message = get_assistant_message()
    assistant_message["id"] = request.responseId
    message_store.add_message(assistant_message)

Set your API key

Make sure to set your Thesys API key as an environment variable:

export THESYS_API_KEY=<your-api-key>

Next.js (.env.local)

THESYS_API_KEY=<your-api-key>

Your API endpoint is now ready to handle streaming chat conversations with the C1 model!

Getting Started

Basics

Interactivity

Styling

Conversational UI

Artifacts

Advanced

Ecosystem