Skip to main content
Console

Not just calling models,
delivering usable Agents.

Connect Hunyuan, DeepSeek, and other models; orchestrate tools and state with agent-server; stream interactions to Web, Mini Programs, and business apps via AG-UI.

Open AI+Read AI docs
Model · Agent · AG-UI
agent / support-copilotstreaming
Customer Copilot
userCheck delivery status for order TCB-0714.
assistant · thinkingI'll read the order first, then look up the linked shipment.
TOOL TRACEAG-UI events
01query_orderdone
02get_shipmentdone
03render_tracking_cardclient tool
assistant · finalThe order shipped from Shanghai and is en route to the regional hub.
From prompt to product

Models, tools, and UI share one event stream

Text, tool calls, and state changes during Agent execution reach the client step by step via AG-UI — not only the final message.

agent delivery pathag-ui connected
01 · Model

Understand and generate

Hunyuan · DeepSeek · compatible APIs

→
02 · Agent

Reason and call tools

agent-server · Framework adapter

→
03 · UI

Stream to client surfaces

AG-UI · React · Mini Program

eventpayloadstate
RUN_STARTEDthread_42received
TOOL_CALL_ENDget_shipmentrendered
RUN_FINISHEDmessage_18complete

From model API to shippable Agent products

Models are only the start — runtime protocol, business tools, knowledge data, and UI shape the final experience.

01

Managed model access

Call Hunyuan, DeepSeek, and other models through one SDK, or use OpenAI / Anthropic-compatible endpoints with existing toolchains.

MODEL API
02

Streaming output and tool calls

generateText for one-shot generation, streamText for incremental text, and Function Tools connect models to business actions.

STREAM / TOOL
03

Agent Server and AG-UI

Adapt LangChain, LangGraph, CrewAI, and other frameworks into AG-UI services with unified messages, state, and tool events.

AGENT SERVER
04

Multi-platform Agent UI

React and Mini Program components render messages, reasoning, and tool calls — or customize UI on the Core layer.

AGENT UI
05

PostgreSQL vector foundation

Use pgvector, vectorscale, and Chinese tokenization extensions in PG mode to organize retrieval and RAG pipelines.

VECTOR
06

AI Builder and ToolKit

Generate apps from natural language, or let MCP / Skill-enabled dev tools manage CloudBase resources and workflows.

BUILD WITH AI
“
AI products feel real not because of another chat box, but because models call real business capabilities and the process is understandable in the UI.
Product design principle
Protocol over coupling

Decouple Agent frameworks from UI with AG-UI

Swap Agent frameworks on the backend while the frontend consumes the same events; client tools can bring business UI back into the execution loop.

View AG-UI protocol
AGENT DELIVERY
protocolAG-UI / SSE
runtimeagent-server
webReact Core / UI
wechatMini Program components

Connect models first, then wire Agents to UI

Examples use current in-repo SDK, agent-server, and React UI docs — no incorrect competitor model references.

Managed model

Stream managed models on the server

Node SDK generates text via the cloudbase model group; available models and provisioning follow the dev platform.

  • generateText returns the full result
  • streamText provides an async text stream
  • Model names are managed in app configuration
stream-model.js
const tcb = require('@cloudbase/node-sdk')

const app = tcb.init({
  env: '<envId>',
  timeout: 60000
})

const model = app.ai().createModel('cloudbase')
const result = await model.streamText({
  model: 'hy3-preview',
  messages: [
    { role: 'user', content: 'Summarize this weekly report' }
  ]
})

for await (const text of result.textStream) {
  process.stdout.write(text)
}
Agent server

Wrap Agents as AG-UI HTTP services

agent-server exposes Express routes; adapters convert framework Agent messages and tool events to the unified protocol.

  • TypeScript and Python server support
  • Framework logic separated from protocol delivery
  • Suitable for CloudRun deployment
agent-server.ts
import express from 'express'
import { createExpressRoutes }
  from '@cloudbase/agent-server'
import { LangchainAgent }
  from '@cloudbase/agent-adapter-langchain'
import { createAgent as createGraph }
  from './agent.js'

const app = express()

createExpressRoutes({
  express: app,
  createAgent: () => ({
    agent: new LangchainAgent({
      agent: createGraph()
    })
  })
})

app.listen(9000)
React delivery

Connect client surfaces to Agents with Transport

React Core manages protocol and state; UI components provide ready-made messages, tool calls, and input areas.

  • CloudBaseTransport connects to a specified Agent
  • Built-in Chinese and English UI copy
  • Drop to Core layer for fully custom UI
assistant.tsx
import { AgKit, CloudBaseTransport }
  from '@ag-kit/react-core'
import { AgKitUI }
  from '@cloudbase/agent-react-ui'

const transport = new CloudBaseTransport({
  app,
  agentId: '<agent-id>'
})

export function Assistant() {
  return (
    <AgKit transport={transport}>
      <AgKitUI
        locale="en-US"
        inputPlaceholder="Ask me anything"
      />
    </AgKit>
  )
}
AI ecosystem

Combine models, frameworks, data, and dev tools

Keep familiar Agent frameworks while connecting deployment, protocol, and CloudBase resources.

01

Model layer

Managed models and OpenAI / Anthropic-compatible APIs.

02

Agent layer

LangChain, LangGraph, CrewAI, and custom adapters.

03

Delivery layer

React, Mini Program, AI Builder, and MCP tools.

HunyuanDeepSeekstreamTextFunction Toolagent-serverAG-UILangChainLangGraphCrewAIAgent UIpgvectorvectorscaleAI BuilderMCPSkill
Build an AI product

Bring models into production, not just the Playground

Pick a model, connect a real tool, then deliver the execution process to the user interface.

Start building AgentsView Agent development