llms.txt
Compare with other sites' llms.txt files →file: ./content/docs/community.en.mdx
meta: {
"title": "社区",
"description": "欢迎加入 Sealos 开源社区"
}
file: ./content/docs/index.en.mdx
meta: {
"title": "Sealos Docs",
"description": "Find quickstart guides, tutorials, best practices, deployment templates, system design docs, self-hosting solutions and more cloud native resources."
}
import { Text, Code, Play, Database } from 'lucide-react';
import { templateDomain } from '@/config/site';
<Cards>
<Card icon={<Text />} href="/docs/overview/intro" title="How Sealos DevBox works">
Understand what Sealos DevBox is and what it can do, include the key
features and advantages.
</Card>
<Card icon={<Code />} href="/docs/guides/devbox" title="Guides">
Learn how to create and manage your Projects, develop your application,
create releases, and deploy your application.
</Card>
<Card icon={<Play />} href="/docs/quick-start" title="Quickstarts">
Develop & deploy in minutes. Jump start your development with Sealos DevBox.
</Card>
<Card icon={<Database />} href="/docs/guides/databases/postgresql" title="Databases">
Step-by-step guides on how to deploy and connect to databases in Sealos
DevBox.
</Card>
</Cards>
***
<br />
<center>
<h1>Comprehensive development stack support</h1>
</center>
<center>
Launch specialized development environments for any framework or language.
</center>
<br />
import {
NodejsIcon,
GoIcon,
JavaIcon,
PHPIcon,
PythonIcon,
RustIcon,
} from '@/components/ui/icons';
<Cards>
<Card icon={<NodejsIcon />} href="/docs/guides/databases/postgresql/nodejs" title="Node.js">
Node.js is a runtime environment that allows you to run JavaScript code
outside of a browser.
</Card>
<Card icon={<GoIcon />} href="/docs/guides/databases/postgresql/go" title="Go">
Go is a statically typed, compiled programming language designed at Google.
</Card>
<Card icon={<JavaIcon />} href="/docs/guides/databases/postgresql/java" title="Java">
Java is a high-level, class-based, object-oriented programming language that
is designed to have as few implementation dependencies as possible.
</Card>
<Card icon={<PHPIcon />} href="/docs/guides/databases/postgresql/php" title="PHP">
PHP is a popular general-purpose scripting language that is especially
suited to web development.
</Card>
<Card icon={<PythonIcon />} href="/docs/guides/databases/postgresql/python" title="Python">
Python is an interpreted, high-level, general-purpose programming language.
</Card>
<Card icon={<RustIcon />} href="/docs/guides/databases/postgresql/rust" title="Rust">
Rust is a systems programming language that runs blazingly fast, prevents
segfaults, and guarantees thread safety.
</Card>
</Cards>
<br />
<center>
<a href="/">View all supported languages and frameworks ></a>
</center>
***
<center>
<h1>Deploy your application in minutes</h1>
</center>
<center>Quickly deploy applications via the App Store.</center>
<br />
<Cards>
<Card href={templateDomain + '/deploy?templateName=fastgpt'} title="FastGPT" />
<Card href={templateDomain + '/deploy?templateName=wordpress'} title="Wordpress" />
<Card href={templateDomain + '/deploy?templateName=flarum'} title="Flarum" />
<Card href={templateDomain + '/deploy?templateName=headscale'} title="Headscale" />
<Card href={templateDomain + '/deploy?templateName=teable'} title="Teable" />
<Card href={templateDomain + '/deploy?templateName=s-pdf'} title="Stirling-PDF" />
</Cards>
<br />
<center>
<a href={templateDomain} target="_blank">
View all apps >
</a>
</center>
file: ./content/docs/quick-start.en.mdx
meta: {
"title": "Quick Start Tutorial",
"icon": "Album",
"keywords": [
"Sealos DevBox",
"Next.js",
"cloud development",
"Kubernetes",
"OCI image",
"Cursor IDE",
"remote development",
"cloud deployment",
"containerization",
"DevOps"
],
"description": "Learn how to create, develop, and deploy a Next.js app using Sealos DevBox. This guide covers project setup, remote development with Cursor IDE, and cloud deployment."
}
import { AppDashboardLink } from '@/components/docs/Links';
Sealos DevBox is an all-in-one platform designed for integrated online development, testing, and production. It offers a seamless solution for creating environments and database dependencies with just a single click, allows developers to work locally using their preferred IDEs while streamlining setup processes and enabling automatic application deployment.
**In this guide We'll demonstrate how to how to create a minimal Next.js demo project with Sealos DevBox.**
## Create a DevBox Project
<div className="fd-steps [&_h5]:fd-step">
<h5>
Click on the "DevBox" icon from your <AppDashboardLink />, then click on the
"Create New Project" button to create a new project.
</h5>
<h5>
In the "Runtime" section, choose "Next.js" as the development framework. Use
the sliders to set the CPU cores and memory for the project.
</h5>

<h5>
After setting up the basic environment, you'll need to configure the network
settings for your project:
</h5>

* Scroll down to the "Network" section of the configuration page.
* Container Port:
* Enter "3000" in the Container Port field. This is the default port that Next.js uses for development.
* If you need additional ports, click the "Add Port" button and specify them.
* Enable Internet Access:
* Toggle the switch to enable internet access for your DevBox. This allows external users to access your Next.js application through the public internet using the provided domain.
* Domain:
* By default, Sealos provides a subdomain for your application.
* If you want to use a custom domain, click on "Custom Domain" and follow the instructions to set it up.
Remember that the container port (3000) should match the port your Next.js application is configured to run on. If you change the port in your Next.js configuration, make sure to update it here as well.
<h5>Click on the "Create" button to create your project.</h5>
</div>
## Connect with Cursor IDE
After creating your project, you'll see it listed in the DevBox List. Each project has an "Operation" column with various options.

<div className="fd-steps [&_h5]:fd-step">
<h5>To connect to your project's DevBox runtime using Cursor IDE:</h5>
* Locate your project in the DevBox List.
* In the "Operation" column, click on the dropdown arrow next to the VSCode icon.
* From the dropdown menu, select "Cursor".
* Click on the "Cursor" option that appears.
<h5>
When you click on "Cursor", it will launch the Cursor IDE application on your
local machine. Within Cursor, a popup window will appear, prompting you to
install the DevBox plugin for Cursor. This plugin enables SSH remote
connection to the DevBox runtime.
</h5>
* Follow the instructions in the Cursor popup to install the DevBox plugin.
* Once installed, Cursor will establish a remote connection to your DevBox runtime.
</div>
<Callout type="info">
You can switch between different IDE options (VSCode, Cursor, or VSCode
Insiders) at any time by using the dropdown menu in the "Operation" column.
</Callout>
## Develop
<div className="fd-steps [&_h5]:fd-step">
<h5>
After the connection is established, you'll be able to access and edit your
project files directly within the Cursor IDE environment.
</h5>

This remote connection allows you to develop your Next.js application using Cursor IDE, with all the benefits of a cloud-based development environment: - Your code runs in the DevBox runtime, ensuring consistency across development and production environments. - You can access your project from anywhere, on any device with Cursor installed. - Collaboration becomes easier as team members can connect to the same DevBox runtime.
<h5>You can start debugging your Next.js application:</h5>
* Open the terminal within Cursor IDE.
* Navigate to your project directory if you're not already there.
* Run the following command to start the Next.js development server:
```bash
npm run dev
```
* This command will start your Next.js application in development mode.
<h5>To access your running application:</h5>
* Return to the Sealos DevBox List in your browser.
* Find the project you just created.
* Click on the "Detail" button on the right side of your project's row.
<h5>In the project details page:</h5>
* Look for the "Network" section.
* You'll see an "External Address" field.
* Click on this external address.

<h5>
This will open your Next.js application in a new browser tab, allowing you to
view and interact with your running service.
</h5>

</div>
## Release
After you've developed and tested your Next.js application, you can release it as an OCI (Open Container Initiative) image. This allows you to version your application and prepare it for deployment.
1. In the Cursor IDE terminal, navigate to your project directory and run the build command:
```bash
npm run build
```
This command creates a production-ready build of your Next.js application in the '.next' directory.
2. Navigate to your project's details page:
* Go to the Sealos DevBox List in your browser.
* Find your project and click on the "Detail" button on the right side of your project's row.
3. On the project details page, look for the "Version" section.
4. Click on the "Release" button located in the top right corner of the "Version" section.
5. A "Release" dialog box will appear. Here, you need to provide the following information:
* Image Name: This field is pre-filled with your project's image name.
* Tag: Enter a version tag for your release (e.g., v1.0).
* Description: Provide a brief description of this release (e.g., "Initial release" or "Bug fixes for login feature").

6. After filling in the required information, click the "Release" button at the bottom of the dialog box.
7. The system will process your release. Once completed, you'll see a new entry in the "Version" section of your project details page, showing the tag, status, creation time, and description of your release.

By following these steps, you've successfully created an OCI image of your Next.js application. This image can now be used for deployment or shared with other team members. Each release creates a snapshot of your current code, allowing you to maintain different versions of your application and easily roll back if needed.
<Callout type="info">
Remember to create new releases whenever you make significant changes or reach
important milestones in your project. This practice helps in maintaining a
clear history of your application's development and facilitates easier
deployment and collaboration.
</Callout>
## Deploy
After releasing your Next.js application as an OCI image, you can deploy it to Sealos Cloud for production use. Here's how to do it:
1. In your project's details page, locate the "Version" section.
2. Find the release you want to deploy and click the "Deploy" button in the "Operation" column.
3. This will redirect you to the App Launchpad application within Sealos.
4. In the App Launchpad application, follow the deployment wizard to configure your application settings. This may include:
* Selecting the appropriate environment
* Setting resource limits (CPU, memory)
* Configuring environment variables if needed
* Setting up any required volumes or persistent storage

5. Once you've configured all necessary settings, click the "Deploy Application" button in the top right corner to start the deployment process.
6. You'll be taken to the application details view within App Launchpad.
7. Once the status is "Running", Click on the address provided under "Public Address". This will open your deployed Next.js application in a new browser tab.

By following these steps, you've successfully deployed your Next.js application to Sealos Cloud using the App Launchpad application. Your application is now accessible via the public address, allowing users to interact with it from anywhere on the internet.
<Callout type="info">
You can always update your application by creating a new release in DevBox and
repeating this deployment process with the new version using App Launchpad.
</Callout>
This workflow allows you to develop and debug your Next.js application in a cloud environment while still using your preferred local IDE. The external address makes it easy to share your work with team members or clients, as they can access your running application from anywhere with an internet connection.
file: ./content/docs/AI/mcp.en.mdx
meta: {
"title": "MCP (Model Context Protocol)",
"description": "Learn how to use Model Context Protocol (MCP) services on the Sealos platform to connect AI models with external tools and data sources through standardized interfaces.",
"keywords": [
"MCP",
"Model Context Protocol",
"Sealos",
"AI integration",
"large language models",
"tool calling"
]
}
## What is Model Context Protocol (MCP)?
The [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) is a game-changing standard that lets AI models talk to external tools and data sources seamlessly. Instead of building custom integrations for every service, developers can integrate once and connect to any MCP-compatible system.
### The Problem MCP Solves
Here's the challenge: AI models are smart, but they're isolated. They can't access your databases, check your billing, or run code in your development environment. To make AI truly useful, you need to connect it to real-world systems.
The traditional approach? Build custom integrations for every single service. Each one has different APIs, authentication methods, and data formats. It's a maintenance nightmare that gets worse as you add more tools.
### MCP Changes Everything
MCP is like having a universal translator for AI integrations. Here's how it works:
**For Developers**: Write one MCP integration and connect to any MCP-compatible service. No more custom connectors for every tool.
**For Service Providers**: Build one MCP interface and instantly work with any MCP-enabled AI application.
**Think USB-C for AI**: Just like USB-C replaced dozens of different charging cables, MCP replaces dozens of different API integrations with one standard protocol.
### How MCP Works: The Three-Part System
MCP uses a simple client-server model with three key components:
* **MCP Host**: Your AI application (like Cursor, VS Code, or ChatGPT)
* **MCP Client**: The connection bridge that your AI app creates
* **MCP Server**: The external service that provides tools and data (like Sealos)
**Simple Example**: Your Cursor editor (Host) creates a connection (Client) to talk to Sealos services (Server). Want to connect to multiple services? Your editor just opens multiple connections.
## Sealos MCP: Your Cloud Platform, AI-Ready
Sealos has built MCP servers for all its major platform capabilities. Using StreamableHttp communication, these servers work seamlessly with any MCP-compatible IDE or AI application.
**Bottom line**: You can now control your entire Sealos infrastructure through natural language conversations with AI.
### What You Can Do with Sealos MCP
Here's what's available right now:
* **🛠️ DevBox**: Spin up development environments and run code
* **🗄️ Database**: Query and manage your databases
* **💰 Cost Center**: Check billing and manage expenses
* **📊 Observability**: Monitor performance and view logs
**Note**: Service availability varies by region. Check your Sealos console to see what's available in your zone.
### Quick Authentication Setup
Sealos uses your KubeConfig for authentication. Here's the simple 3-step process:
**Step 1: Get Your KubeConfig**
1. Go to [Sealos Console](https://os.sealos.io)
2. Click your profile picture (top right)
3. Select "KubeConfig" and copy the content
**Step 2: URL Encode It**
Choose any of these methods to URL-encode your KubeConfig:
**Method 1: Online Tool (Easiest)**
1. Open [URL Encoder](https://www.urlencoder.org/) or search "URL encoder"
2. Paste your KubeConfig content
3. Click "Encode"
4. Copy the encoded result
**Method 2: Browser Console**
1. Press `F12` on any webpage to open developer tools
2. Go to "Console" tab
3. Type this and press Enter:
```javascript
encodeURIComponent(`paste your KubeConfig here`)
```
4. Copy the encoded output
**Method 3: Python (if installed)**
1. Open terminal
2. Type `python3` to enter Python
3. Run this code:
```python
import urllib.parse
kubeconfig = """paste your KubeConfig here"""
encoded = urllib.parse.quote(kubeconfig)
print(encoded)
```
4. Copy the encoded result
**Step 3: Use It**
Add this header to your MCP configuration:
```
Authorization: <your-url-encoded-kubeconfig>
```
**Example**: `apiVersion: v1` becomes `apiVersion%3A%20v1`
**Pro Tip**: Save your encoded KubeConfig somewhere safe—you'll use it for all MCP configurations.
## Ready to Get Started?
### Before You Begin: Two Things You Need
**1. Your MCP Service URL**
* Log into [Sealos Console](https://os.sealos.io)
* Find the MCP services section for your region
* Copy the URL for the service you want to use
**2. Your Authentication Token**
* Follow the authentication steps above to get your URL-encoded KubeConfig
* Keep it handy—you'll paste it into your IDE configuration
**That's it!** Now let's connect your favorite AI tool to Sealos.
## Connect Your AI Tool to Sealos
### Cherry Studio Setup
[Cherry Studio](https://cherry-ai.com/) makes MCP configuration visual and straightforward.
**Quick Setup:**
1. **Settings** → **MCP Servers** → **Add Server**
2. **Fill in the details:**
* **Name**: `Sealos` (or whatever you prefer)
* **Type**: `Streamable HTTP (StreamableHttp)`
* **URL**: Your Sealos MCP service URL
* **Headers**: `Authorization=<your-url-encoded-kubeconfig>`
3. **Hit the green start button** and wait for "Connected" status
**Start Using It:**
Once connected, just chat normally. When you need Sealos functionality, select the MCP tools and ask.
### VS Code Setup
VS Code gets MCP powers through extensions. Here's the streamlined setup:
**Quick Setup:**
1. **Open AI Chat** (right sidebar) → **Agent Mode** → **Tools icon**
2. **Find MCP settings** → **Gear icon** → **Add new server**
3. **Configure:**
* **Name**: `Sealos Platform`
* **URL**: Your Sealos MCP service URL
* **Headers**:
```json
{
"Authorization": "<your-url-encoded-kubeconfig>"
}
```
4. **Save** → VS Code auto-connects
**Code While You Chat:**
Now you can ask your AI assistant to interact with Sealos while you code.
### Cursor Setup
[Cursor](https://www.cursor.com/) has the best native MCP support. Setup is super clean:
**Quick Setup:**
1. **Settings gear** (top right) → **MCP Servers** → **New MCP Server**
2. **Paste this config** (replace the URL and auth token):
```json
{
"name": "Sealos MCP",
"url": "https://your-sealos-mcp-endpoint.com",
"headers": {
"Authorization": "<your-url-encoded-kubeconfig>"
}
}
```
3. **Save** → Cursor auto-verifies → Look for "Connected" status
**AI-Powered Development:**
Now your AI coding assistant can manage your entire Sealos infrastructure.
### Trae Setup
Trae keeps it simple with m