> For the complete documentation index, see [llms.txt](https://docs.stg.ai.neevcloud.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.stg.ai.neevcloud.com/tutorials/readme.md).

# Overview

Hands-on guides for building on NeevCloud. Pick the product you are working with, follow the guide, and you end up with something running: a model answering requests, an agent working in an isolated sandbox, or a GPU serving a model or training one.

The guides are grouped by product, so you can find the right one without knowing its exact name.

## Where to begin

| If you want to                                                 | Start with                                                                                                                                                                                                                    |
| -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Call a hosted model from your own app                          | [Make Your First Model API Call](/tutorials/start-here/access-your-first-model-api-in-minutes.md)                                                                                                                             |
| Run code or an AI agent somewhere isolated from your machine   | [Create Your First Sandbox (JavaScript SDK)](/tutorials/start-here/create-your-first-sandbox-in-neevcloud-agentic-studio-javascript-sdk.md)                                                                                   |
| Have an assistant that works with your email, calendar or chat | [Deploy OpenClaw on Agentic Studio](/tutorials/openclaw/get-started/deploy-openclaw-using-agentic-studio-on-neevcloud.md)                                                                                                     |
| Run, serve or train a model on a dedicated GPU                 | [Ubuntu 24.04 for Custom AI Environments](/tutorials/gpu-cloud/environments-and-frameworks/building-custom-ai-environments-using-ubuntu24.04-template-on-neevcloud.md) or a ready-made template under [GPU Cloud](#gpu-cloud) |

You need a NeevCloud account for every guide. The Model API, sandbox and agent guides also use an API key, so do [Create an API Key](/tutorials/start-here/create-api-key.md) first if you do not have one.

***

## Start Here

Three short guides that cover the basics the rest of the tutorials build on.

| Tutorial                                                                                                                                    | What you will do                                                                                                          |
| ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| [Create an API Key](/tutorials/start-here/create-api-key.md)                                                                                | Create a key in the Console and choose which resource type it works with.                                                 |
| [Make Your First Model API Call](/tutorials/start-here/access-your-first-model-api-in-minutes.md)                                           | Call a hosted model with no infrastructure to set up.                                                                     |
| [Create Your First Sandbox (JavaScript SDK)](/tutorials/start-here/create-your-first-sandbox-in-neevcloud-agentic-studio-javascript-sdk.md) | Create an isolated sandbox from code, where you can run commands and test applications without touching your own machine. |

***

## Model API

Hosted models behind an OpenAI-compatible API. You send requests; NeevCloud handles the GPUs, scaling and uptime.

**Inference**

| Tutorial                                                                                                                              | What you will do                                                   |
| ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| [Send an Inference Request with the Model API](/tutorials/model-api/inference/send-an-inference-request-using-neevcloud-model-api.md) | Send a prompt to a model endpoint over HTTP and read the response. |

**Models**

| Tutorial                                                                                                    | What you will do                                                                                         |
| ----------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| [Run GLM-5.2 with the Model API](/tutorials/model-api/models/glm-5-2-model-api-tutorial.md)                 | Try GLM-5.2 in the Model Playground, then call it with cURL, Python and JavaScript.                      |
| [Run Kimi K3 with the Model API](/tutorials/model-api/models/access-kimi-k3-through-neevcloud-model-api.md) | Use Kimi K3, a reasoning-focused model for coding, research and complex problems, from your application. |

**Use with coding tools**

| Tutorial                                                                                                                                            | What you will do                                                                                                         |
| --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| [Connect the Model API to Claude Code with CCR](/tutorials/model-api/use-with-coding-tools/connect-neevcloud-model-api-to-claude-code-using-ccr.md) | Add NeevCloud as a provider in Claude Code Router, add GLM and MiniMax, and launch Claude Code through an Agent Profile. |

***

## Sandboxes and Coding Agents

Sandboxes are isolated environments with their own filesystem and processes. They let agents run code, install packages and edit files without any of it happening on your laptop.

**Build on sandboxes**

| Tutorial                                                                                                                                                  | What you will do                                                                                                                  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| [Run Sandboxes with ComputeSDK](/tutorials/sandboxes-and-coding-agents/build-on-sandboxes/running-neevcloud-sandboxes-with-computesdk.md)                 | Use ComputeSDK's unified interface with the NeevCloud provider to create sandboxes, run commands, manage files and expose apps.   |
| [Connect VS Code to a Sandbox](/tutorials/sandboxes-and-coding-agents/build-on-sandboxes/connect-vscode-to-neevcloud-sandbox.md)                          | Use a sandbox as a remote VS Code environment over SSH, opened on its `/workspace` directory.                                     |
| [Run an AI Agent on Secure Serverless Compute](/tutorials/sandboxes-and-coding-agents/build-on-sandboxes/run-an-ai-agent-on-secure-serverless-compute.md) | Watch a sandbox block an unknown host, undo a destructive command with a snapshot, read the audit trail, and pause and resume it. |

**Coding agents**

| Tutorial                                                                                                                                       | What you will do                                                                                                        |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| [Deploy Claude Code on Agentic Studio](/tutorials/sandboxes-and-coding-agents/coding-agents/deploy-claude-code-on-neevcloud-agentic-studio.md) | Deploy a ready-made Claude Code environment inside a dedicated sandbox instead of installing it yourself.               |
| [Run Claude Code 24/7 in a Sandbox](/tutorials/sandboxes-and-coding-agents/coding-agents/run-claude-code-24-7-on-a-sandbox.md)                 | Create a Claude Code agent with neev-cli, run it in a persistent tmux session, and continue from your phone or the web. |
| [Run OpenAI Codex in a Sandbox](/tutorials/sandboxes-and-coding-agents/coding-agents/run-openai-codex-in-a-neevcloud-sandbox.md)               | Point Codex at a sandbox so its shell commands and file edits run there, not on your machine.                           |
| [Run DeepSeek Harness in a Sandbox](/tutorials/sandboxes-and-coding-agents/coding-agents/run-deepseek-harness-in-a-neevcloud-sandbox.md)       | Move the Harness's files, shell, terminal and language-server work into a short-lived isolated sandbox.                 |

**Safety**

| Tutorial                                                                                                                            | What you will do                                                                                                                                   |
| ----------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Run Agents Safely: Isolation and Egress Guardrails](/tutorials/sandboxes-and-coding-agents/safety/run-agents-safely-guardrails.md) | Learn the three guardrails (isolation, deny-by-default network egress, and disposable sandboxes) that make it safe to give an agent full autonomy. |

***

## OpenClaw

OpenClaw is an open-source agent platform with a web interface for creating and talking to agents. Each deployment runs in its own sandbox, and you connect it to your tools through MCP connectors. Deploy it first, then add the connectors you need.

**Get started**

| Tutorial                                                                                                                  | What you will do                                          |
| ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
| [Deploy OpenClaw on Agentic Studio](/tutorials/openclaw/get-started/deploy-openclaw-using-agentic-studio-on-neevcloud.md) | Deploy the OpenClaw template and choose a model provider. |

**Connectors**

| Tutorial                                                                                                          | What you will do                                                                                                                             |
| ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| [Connect Gmail](/tutorials/openclaw/connectors/connect-gmail-mcp-to-openclaw-on-neevcloud.md)                     | Let the agent search and read your Gmail messages.                                                                                           |
| [Connect Google Calendar](/tutorials/openclaw/connectors/connect-google-calendar-mcp-to-openclaw-on-neevcloud.md) | Authorize calendar access so the agent can read your calendar and answer questions about your schedule.                                      |
| [Connect Slack](/tutorials/openclaw/connectors/connect-slack-mcp-with-agentic-studio-openclaw-agent-template.md)  | Configure the Slack MCP server so the agent can interact with your Slack channels.                                                           |
| [Connect Mattermost](/tutorials/openclaw/connectors/connect-mattermost-mcp-to-openclaw-on-neevcloud.md)           | Let the agent read messages, search channels and post in Mattermost.                                                                         |
| [Connect a NeevCloud Sandbox](/tutorials/openclaw/connectors/connect-sandbox-mcp-to-openclaw-on-neevcloud.md)     | Give the agent a real workspace where it can run commands, read and write files and start long-running processes that persist between calls. |

**Workflows**

| Tutorial                                                                                                                                           | What you will do                                                                                                                      |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| [Automate Email Triage with Gmail and Google Calendar](/tutorials/openclaw/workflows/automate-email-triage-with-two-mcp-connectors-on-openclaw.md) | Combine two connectors so the agent reads recent emails from a sender, drafts a reply to each and creates a follow-up calendar event. |

***

## GPU Cloud

Dedicated GPU instances. Most guides start from a ready-made AI template that already has drivers and CUDA installed, so you skip the setup.

**Environments and frameworks**

| Tutorial                                                                                                                                                               | What you will do                                                                                  |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| [Ubuntu 22.04 for Custom GPU Workloads](/tutorials/gpu-cloud/environments-and-frameworks/running-ubuntu22.04-template-for-custom-gpu-workloads-on-neevcloud.md)        | Start from a minimal OS with NVIDIA drivers and CUDA, and install the frameworks you choose.      |
| [Ubuntu 24.04 for Custom AI Environments](/tutorials/gpu-cloud/environments-and-frameworks/building-custom-ai-environments-using-ubuntu24.04-template-on-neevcloud.md) | The same idea on a newer kernel and updated system packages.                                      |
| [PyTorch with Jupyter](/tutorials/gpu-cloud/environments-and-frameworks/deploy-pytorch-neevcloud-gpu-jupyter.md)                                                       | Run PyTorch experiments on a GPU from a Jupyter notebook.                                         |
| [TensorFlow with CUDA](/tutorials/gpu-cloud/environments-and-frameworks/running-tensorflow-cuda-template-on-neevcloud-gpu.md)                                          | Use a template with drivers, CUDA, cuDNN and a GPU-enabled TensorFlow already in place.           |
| [Network Storage Across Instances](/tutorials/gpu-cloud/environments-and-frameworks/from-gpu-setup-to-data-persistence-accessing-network-storage-across-instances.md)  | Keep datasets, models and outputs on storage that survives deleting and recreating GPU instances. |

**LLM serving**

| Tutorial                                                                                                                                         | What you will do                                                        |
| ------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------- |
| [Serve an LLM with the vLLM Template](/tutorials/gpu-cloud/llm-serving/llm-inference-using-the-vllm-ai-template-on-neevcloud.md)                 | Deploy a GPU instance and run high-throughput LLM inference end to end. |
| [Run Local LLMs with Ollama and Open WebUI](/tutorials/gpu-cloud/llm-serving/running-local-llms-using-ollama-and-open-webui-on-neevcloud-gpu.md) | Run models on your own GPU and chat with them from a browser.           |

**Fine-tuning**

| Tutorial                                                                                                                                          | What you will do                                                                                    |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| [Fine-Tune LLMs with H2O LLM Studio](/tutorials/gpu-cloud/fine-tuning/fine-tuning-large-language-models-using-h2o-llm-studio-on-neevcloud-gpu.md) | Fine-tune, monitor and evaluate a model from a web interface, with no manual setup.                 |
| [Fine-Tune LLMs with LoRA Using Axolotl](/tutorials/gpu-cloud/fine-tuning/fine-tuning-llms-with-lora-using-axolotl-template-on-neevcloud.md)      | Use LoRA to fine-tune with far fewer trainable parameters, so training needs less compute and time. |

**Image generation**

| Tutorial                                                                                                   | What you will do                                                  |
| ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| [Run ComfyUI](/tutorials/gpu-cloud/image-generation/running-comfyui-using-ai-template-on-neevcloud-gpu.md) | Build and run image-generation workflows on a pre-configured GPU. |

**Speech and voice**

| Tutorial                                                                                                                                                                      | What you will do                                                                       |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| [Run Whisper on the PyTorch Template](/tutorials/gpu-cloud/speech-and-voice/speech-to-text/run-whisper-on-neevcloud-pytorch-gpu-template.md)                                  | Transcribe audio to text with OpenAI Whisper.                                          |
| [Deploy Whisper with Triton Inference Server](/tutorials/gpu-cloud/speech-and-voice/speech-to-text/deploy-openai-whisper-for-speech-to-text-using-triton-inference-server.md) | Serve Whisper through a pre-configured Triton Inference Server.                        |
| [Deploy NVIDIA NeMo](/tutorials/gpu-cloud/speech-and-voice/speech-to-text/speech-to-text-nvidia-nemo-neevcloud-gpu.md)                                                        | Run NVIDIA NeMo speech-to-text on the PyTorch template.                                |
| [Deploy TTS Models on the PyTorch Template](/tutorials/gpu-cloud/speech-and-voice/text-to-speech/deploying-tts-models-on-pytorch-template.md)                                 | Load a text-to-speech model and generate speech from text.                             |
| [Build a Real-Time Voice Agent with vLLM](/tutorials/gpu-cloud/speech-and-voice/voice-agents/build-voice-agent-using-vllm-template.md)                                        | Combine speech recognition, an inference server and text-to-speech into a voice agent. |
| [Build a Voice AI Pipeline on the Ubuntu Template](/tutorials/gpu-cloud/speech-and-voice/voice-agents/building-voice-ai-pipeline-on-neevcloud-gpu-ubuntu-template.md)         | Chain Whisper, GLM-5.2 and Bark so an app can listen, understand and reply.            |

**Developer tools**

| Tutorial                                                                                                                     | What you will do                                                              |
| ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| [Connect VS Code to a GPU (Linux and macOS)](/tutorials/gpu-cloud/developer-tools/connect-neevcloud-gpu-to-vs-code.md)       | Edit locally in VS Code while your code runs on a remote GPU over Remote SSH. |
| [Connect VS Code to a GPU (Windows)](/tutorials/gpu-cloud/developer-tools/how-to-use-neevcloud-gpus-with-vs-code-windows.md) | Deploy an Ubuntu 22.04 GPU and connect to it from VS Code on Windows.         |
