Platform For AI:PAI-LangStudio Retirement and Migration Guide

1.1 What is Model Studio

Alibaba Cloud Model Studio is a one-stop large model service platform designed for enterprises and developers. It provides model services, application building, knowledge bases, a tool ecosystem, and publishing and operations capabilities. Model Studio is well suited to take over the application building, debugging, deployment, and observability workloads that you previously ran on LangStudio.

For the detailed feature mapping and migration approach, see 2. Migration Overview. For more information, see Alibaba Cloud Model Studio Overview and Model Studio Application Types.

1.2 Pre-migration Permission Setup

Before you migrate, apply for the required permissions in advance. Ask the owner of your Alibaba Cloud account to grant RAM users of LangStudio developers the read and write permissions for Model Studio applications, create workspaces, and apply for API keys. For specific permission items and authorization procedures, see Permission management and Model Studio System Permission Policy Reference.

2.1 Feature Mapping

The following table maps LangStudio features to their Model Studio equivalents:

2.2 Application Type Mapping

Prioritize migrating to workflow or high-code application types and rebuild configurations individually:

Model Studio also provides agent apps, which offer simpler configuration. Evaluate whether this type suits your business scenario.

3.1 Node Count and Coverage

First identify nodes that have significant differences or no direct equivalent. Rebuild all other nodes on the Model Studio canvas.

For nodes marked as "Minor differences," rebuild the configuration on the Model Studio side according to the differences listed in the table above. For complete parameter descriptions, see Workflow application. The following sections cover the nodes with "Significant differences" and "Must implement manually."

3.2 Nodes with Significant Differences

The following sections focus only on the key differences that require redesign.

{{ variable }}

${node.variable}

@tool
def invoke(...): ...

def main(params):
    return {"output": params["input"]}

{% for doc in documents %}
{{ doc.content }}
{% endfor %}

${KnowledgeBase_1.result}

3.3 Integration Testing

Click Test in the upper-right corner of the canvas to open the test panel. It provides three modes: Text Conversation (multi-turn, retains context; click a node to view its input and output), Text Generation (single-turn, supports synchronous and asynchronous), and Audio/Video Interaction. The upper-right corner also has a Checklist entry that lists the configuration items that must be completed before a run. We recommend reviewing it before testing.

Focus on verifying four types of issues: whether variable references are passed correctly (especially after prompt syntax rewriting), whether conditional branch and loop termination logic match the original application, whether external service calls fail due to unconfigured allowlists, and whether the Script node output structure matches what downstream nodes expect.

4.1 Fundamental Change in Development Approach

LangStudio provides a cloud-based Web IDE. Model Studio high-code applications use local development instead.

The migration process is local development -> package as .whl -> upload -> cloud verification:

If you prefer to continue development and debugging in the cloud, you can use PAI's DSW (Data Science Workshop).

4.2 Project Structure Changes

Typical structure of a LangStudio coding mode application (LLM Basic template):

project/
├── agent.py          # Entry point: FastAPI app and API endpoints
├── agent_loop.py     # Core logic: LLM calls and tool execution loop
├── agui.py           # AG-UI Protocol event stream conversion
├── skills.py         # Skill discovery, loading, and execution
├── requirements.txt
├── .env              # Environment variables
└── README.md

Five changes are required to migrate to Model Studio:

If the entry file is not named main.py, the console displays "Deploying" until it times out. The health check endpoint is how Model Studio determines whether the application started successfully. If the endpoint is unreachable, the deployment is considered failed.

@app.get("/health")
def health_check():
    return "OK"

Implement the default /process endpoint according to the Agent API protocol.

The runtime requires Python >= 3.10:

pip install "agentscope-runtime[deployment]==1.0.0"

4.3 Changes to Model Invocation in Code

Replace the existing model connections with calls to platform models through a Model Studio API key.

Set the DASHSCOPE_API_KEY environment variable, then call models using the DashScope SDK or the OpenAI-compatible protocol:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
resp = client.chat.completions.create(
    model="qwen-plus",
    messages=[{"role": "user", "content": "Hello"}],
)

Model Studio application development currently supports only the China (Beijing) region. For model API calls, use the endpoint for the China (Beijing) region. For self-hosted model integration, see Section 6.1.

4.4 Changes to Knowledge Base Invocation in Code

High-code applications can call the Knowledge Base Retrieve API or SDK directly to perform retrieval.

When calling MCP services, application components, or data connectors, connect to them through their respective interfaces. After adding or removing tools, you must redeploy. For details, see .

4.5 Packaging, Deployment, and Other Model Studio Considerations

Code packages support only the .whl format and are uploaded via the command line:

# First deployment
runtime-fc-deploy --deploy-name <application_name> --whl-path <PATH_TO_WHL> --telemetry enable

# Update deployment
runtime-fc-deploy --update <HIGH_CODE_APP_ID> --whl-path <PATH_TO_WHL> --telemetry enable

Before uploading, configure ALIBABA_CLOUD_ACCESS_KEY_ID, ALIBABA_CLOUD_ACCESS_KEY_SECRET, and optional workspace variables. For the first deployment, follow the console prompts for authorization.

Deployment resources: Select specifications and the minimum number of instances based on your workload. For pricing, refer to the billing page.

Application observability requires adding instrumentation to your code:

from agentscope_runtime.engine.tracing import trace, TraceType

@trace(trace_type=TraceType.LLM, trace_name="llm_call")
def call_llm(...):
    ...

Enable --telemetry enable during deployment to view invocation data in Application Observability.

Networking and publishing: To access enterprise internal network resources, configure networking according to the methods currently supported for high-code applications. Configure domain names and authentication through the gateway.

5.1 Publishing and Invocation

After publishing a workflow or agent app, obtain the API details from the console:

curl -X POST https://dashscope.aliyuncs.com/api/v1/apps/{APP_ID}/completion \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": {"prompt": "Hello"}, "parameters": {}}'

For streaming output, use the X-DashScope-SSE: enable header. For multi-turn conversations, pass session_id or messages as described in the API documentation.

Synchronous call timeouts depend on the access domain: the default domain has a 600-second timeout, while a workspace-specific domain supports up to 3,600 seconds. For longer tasks, switch to asynchronous execution or split the task.

Applications can also be published as application components or connected to sharing channels. The specific scope of support depends on the application type and official documentation.

5.2 Rate Limiting and Quotas

Model Studio calculates RPM and TPM quotas per Alibaba Cloud account and per model. A 429 response indicates that rate limiting has been triggered. RAM users, workspaces, and API keys under the same Alibaba Cloud account share the quota.

Before migrating high-concurrency workloads, evaluate your model quotas and apply for quota increases if necessary. For details, see Rate limiting.

5.3 Production Management and Observability

Application Observability lets you view call chains, inputs and outputs, latency, token consumption, and execution status. The scope of support and data retention period are described in the console documentation.

Model Monitoring lets you view metrics such as call volume, failure rate, rate limiting, and latency. You can integrate with logging, alerting, or monitoring systems based on current capabilities.

Version iteration: Maintain versions in your local code repository. Workflows can be imported and exported to save snapshots. High-code applications are redeployed with a new .whl package using --update. The Model Studio DSL cannot directly import the LangStudio flow.dag.yaml format.

6.1 Connections (Model Access)

Model Studio does not have an equivalent "connection" object. Each type of resource is managed by its respective module, and model calls use API keys.

Model Studio platform models are selected from the ModelGallery and called through API keys using the DashScope or OpenAI-compatible protocol.

Customer-owned models can be handled through three paths:

For details, see Model import and Model deployment.

6.2 Knowledge Bases

Important prerequisite: Vector data in knowledge bases cannot be directly exported or migrated. You must re-parse, re-chunk, and re-vectorize from the original files or other source data. Make sure your source data is complete and accessible.

Model Studio knowledge bases provide four types. The type cannot be changed after creation:

• Multimodal data: Select the access method based on data type.

  • Image Q&A uses public image_url fields in structured data. Audio and video search imports from local storage or OSS.

  • For documents with complex layouts or charts, select the visual understanding scenario in Document Search.

  • Audio and video are imported from local storage or OSS and processed by audio/video parsers.

• Parsing and chunking: Select a parser and chunking strategy before creation. These cannot be modified after creation. Validate retrieval accuracy with sample data first.

• Embedding and ranking models: Select embedding and reranking models at creation time. These cannot be changed after creation. If the embedding dimension changes, re-validate retrieval results.

• Editions: For pricing details, see the official pricing page.

• Association and retrieval limits: These depend on the application type and invocation mode. Verify the current limits before migration.

• Migration steps: Validate and tune with sample data -> create a production knowledge base and import all data -> attach to your application -> benchmark results. Convert source files first if the format is not supported.

For details, see Knowledge base.

6.3 Tools (Plugins)

Model Studio uses plugins to replace tools: agents can select plugins autonomously, while workflows call them deterministically through a Plugin node.

Official plugins include code_interpreter, calculator, text_to_image, quark_search, generate_qrcode, github_search, and more. These can replace some third-party calls.

Custom plugins are configured in the console with interface and authentication details. After completion, they can be published as MCP services. For detailed field descriptions, refer to the console.

For details, see Plugin overview and Custom plugins.

6.4 MCP

Model Studio provides MCP as a platform-level capability, with an MCP Gallery, cloud-hosted services, and a workflow MCP node.

Custom MCP services can be integrated as follows:

• Script deployment: Use type: stdio or type: sse / streamableHttp to connect your service.

• Import from AI Gateway: Wrap existing RESTful APIs as MCP tools.

• Import from Alibaba Cloud OpenAPI: Create a BailianMcpRole* and grant the required permissions.

MCP mounting, tool, and configuration limits are subject to change as capabilities are updated. Verify the current official documentation before migration.

6.5 Other Common Modules

Model Studio also provides the following platform capabilities that have no independent equivalent in LangStudio. Introduce them as needed during migration:

Of these, Skills and Application Evaluation are the most relevant to migration: the former takes over the skill directory from coding mode projects, and the latter lets you build evaluation sets to compare output consistency before and after migration.

Q: My Python nodes use third-party libraries like pandas. The Script node in Model Studio does not support them. What should I do?

Three options: rewrite with standard libraries; move the logic to a Function Compute node (which supports a full dependency environment, with a fixed 60-second timeout); or package as an independent service and call through an API node. For details, see 3.2.2 Python Development to Script Node.

Q: My original application runs inside an enterprise VPC and accesses internal network services. How do I handle this after migration?

When a workflow API node needs to access enterprise internal services, you must expose the service through a supported method and configure access control. For enterprise VPC access to published services, follow the private network access instructions. For details, see 3.2.4 HTTP Request to API Node.

Q: Can I still use my self-hosted models on PAI-EAS after migration?

Yes, but the integration method changes. Model Studio does not support registering external model endpoints as platform models. In a workflow, use an API node to call the model over HTTP, or package it as a custom plugin / MCP service. If the model is a Qwen-based LoRA fine-tuned result, you can also import it into Model Studio. If you need dedicated compute resources, redeploy on the Model Studio dedicated inference service. For details, see 6.1 Connections (Model Access).

Q: Can I directly migrate the vector data from my knowledge base?

No, you cannot migrate it directly. You must re-parse and re-vectorize from the original files or other source data. If you choose a self-hosted RAG solution and already use Elasticsearch / Milvus, the vector data resides in your own instance and can be reused directly.

Q: The Top K limit of the selected retrieval mode is lower than what my original application uses. What should I do?

First optimize chunking and reranking, then evaluate splitting knowledge bases or building a self-hosted RAG service. For details, see 7. Alternative: Building a Self-hosted RAG Service.

Q: How do I confirm that quality has not degraded after migration?

We recommend using the Application Evaluation capability in Model Studio to build an evaluation set. Run your migrated application against real request samples from the original application and compare output consistency and recall accuracy. Focus on the three areas most likely to differ: prompt syntax rewriting, knowledge base recall limit changes, and Script node rewriting.

Q: If Model Studio does not meet our enterprise requirements, are there other options?

We recommend the following three Alibaba Cloud products. Select based on your business requirements and technical roadmap. If you have further questions, consult your account manager.

1. Function Compute AgentRun

   A one-stop Agentic AI infrastructure platform built on a high-code foundation. Based on a serverless architecture, it provides millisecond-level elasticity, enterprise-grade security sandboxes, unified model and tool governance, and end-to-end observability. It covers the full lifecycle of enterprise Agent applications from development and deployment to operations.

2. AgentCore - Agent Building and Governance Platform

   Unified building and governance of enterprise agents across the full agent lifecycle. Supports multiple building modes, unified identity authentication, and team collaboration orchestration. Manages self-developed, open-source harness, and commercial SaaS agents on a single platform.

3. AgentLoop - Agent Observability and Optimization

   A one-stop self-evolution platform for enterprise agents. Covers five core capabilities: observability, evaluation, tuning, memory, and auditing. Helps enterprises build an agent evolution flywheel with a focus on continuous optimization of agent applications.