---
title: "Assistants"
description: "What an assistant is and how to build your first one in a few steps – explained simply for getting started."
canonical_url: "https://meingpt.com/en/docs/platform/assistants"
language: en
---

# Assistants

An **assistant** is an AI helper that you set up once and then reuse for similar tasks – for example "reply to emails in the right tone", "summarize offers", or "translate texts into English".

Instead of explaining what the AI should do every single time, you give an assistant fixed instructions **once**. After that you simply start a chat with it and get going.

![Overview of your assistants](/images/assistants/assistants-neu-overview-en.png)

### Assistant or workflow?

An assistant is flexible – you chat with it freely. A [workflow](/docs/platform/workflows-create) follows fixed steps. Rule of thumb: same sequence every time? → workflow. Free question and answer? → assistant.

## Build your first assistant in 5 steps
You'll find assistants in the left navigation under **Assistants**. Click **+ Create assistant** in the top right – the editor opens. Don't worry: you don't have to fill in everything. Only the first three steps are truly required.

![The assistant editor](/images/assistants/assistants-neu-editor-en.png)

**Give it a name and a short description**

In the **General** section, set a name and an icon (avatar) so you can recognize the assistant later. The description helps you – and colleagues you share it with – understand what it's for.

![Name, model, description and project in the General section](/images/assistants/assistants-neu-general-en.png)

**Choose a model (and optionally a project)**

The model is your assistant's "brain". If you're unsure, leave **Best model** on – it selects GPT-5 by default and only switches automatically to Gemini 2.5 Flash for very long conversations (including attachments). The choice depends on input length, not on task type – for accuracy-critical tasks, pick a specific model manually, see [AI models](/docs/platform/models).

Under **Default project** you can also assign the assistant to a [project](/docs/platform/projects). New chats with this assistant then automatically use that project – handy when you want to keep related conversations in one place.

**Tell it what to do (instructions)**

This is the most important step. In the **Instructions** field (also called the system prompt) you describe the assistant's task in plain words: who is it, what should it do, and how should it respond?

**Tip for getting started:** Just write as if you were explaining the task to a new colleague. For example: "You are a friendly support agent. Answer customer questions briefly, politely, and in English." The **Improve** button helps meinGPT sharpen your prompt.

**Optional: add tools and knowledge**

Does your assistant need more than plain chatting? In the **Tools** section you enable basic tools (e.g. web search, calculator, charts, or **Memory** for a long-term memory) and connect external services like Microsoft 365 or your own MCP servers via **Connectors**.

![Tools and connectors](/images/assistants/assistants-neu-tools-en.png)

Under **Knowledge** you give the assistant access to your own content: upload **files** (PDF, DOCX, PPTX, XLSX) or connect a **data pool** as a searchable knowledge index. That way it answers questions based on your own documents. For your first assistant, feel free to skip this – we'll [look at Memory and Skills in a moment](#memory).

![Knowledge: connect files and data pools](/images/assistants/assistants-neu-knowledge-en.png)

**Save and try it out**

Click **Save** in the top right. Your assistant now appears under **My assistants**. Open it, start a chat, and test whether it responds the way you imagined. You can adjust every setting at any time.

## The editor in detail
You don't need all of this to get started. But if you want more control, here's every section of the assistant editor – just expand what interests you.

### General – avatar, name, model, description

Your assistant's basic information:

- **Avatar:** the profile image. In the sidebar and favorites you only see the avatar – pick it as a clear distinguishing mark. Click it to adjust color and symbol.
- **Name:** short and concise so the task is instantly recognizable.
- **Model:** sets which AI model is used in the chat. Default is **Best model** – it selects GPT-5 and only switches to Gemini 2.5 Flash when the context window is exceeded, regardless of task type. For accuracy-critical tasks, pick a model manually instead. More under [AI models](/docs/platform/models).
- **Description:** explains the assistant's task and function – more detailed than the name, understandable to colleagues too.
- **Default project:** optionally assigns the assistant to a [project](/docs/platform/projects); new chats then use that project automatically.

### Instructions – the system prompt

The **Instructions** section is your main lever for the assistant's behavior. Here you write the **system prompt** – the heart of your assistant. A good system prompt contains:

- The **persona** (the assistant's role)
- The **task** and how it should be solved
- Additional **context**
- The **response format**

**Best practice – structure with `##` sections.** A prompt with clearly separated sections delivers noticeably better results than free-flowing text:

```text
## Role
You are an expert in contract analysis.

## Task
Analyze uploaded contracts and identify risks.

## Rules
- Always answer in English
- Use the data pool for reference documents
- Use the Charts tool for visualizations
```

**System prompts are merged in this order:**

1. **Global prompt** (workspace level, maintained by the admin – tone of voice, company principles)
2. **Assistant prompt** (this configuration – the specific assistant's role and task)
3. **User input** in the chat (the concrete request)

Keep each level focused – duplication leads to fuzzy answers.

**Mention tools explicitly in the prompt:** an enabled tool is often ignored if it isn't mentioned in the system prompt. Reference it concretely, e.g.: *"Use the Charts tool to visualize data when the user asks for charts."*

The system prompt has no placeholder or variable syntax (for example, for the signed-in user's name) – it's passed to the model exactly as written. If the assistant should address the user's name or role, write that directly into the prompt or supply it in the chat. The curly-brace `{{...}}` syntax in the [Prompt Library](/en/docs/platform/prompt-library) is a different, unrelated feature: it only applies to saved prompts and has to be filled in manually on every use – it doesn't auto-populate from user data either.

Top right, the **Improve** button optimizes your prompt automatically (structure, wording, completeness); **Tips** opens context-specific hints.

### Tools – tools, connectors, MCP, databases

Here you equip the assistant with capabilities beyond plain answering. Five areas:

- **Basic tools:** built in and ready to use – calculator, charts, Memory, code sandbox, web search, translator, image generator, and more.
- **Connectors (Live):** live-API connections to external services (Microsoft 365, Google Workspace, Jira, Confluence, HubSpot, Salesforce). They deliver real-time data and perform actions. Overview: [All connectors](/docs/integrations/connectors).
- **Custom MCP:** connect your own MCP servers – for internal systems or special APIs. See [Custom MCP Server](/docs/integrations/custom-mcp-server).
- **Databases:** direct read access to structured data sources (PostgreSQL, MySQL, tables). See [Connect databases](/docs/integrations/databases-overview).
- **Request integration:** missing a tool? Request it here.

**Retry behavior:** if a single tool call fails, the assistant retries it automatically – a red mark on a single tool call is normal and doesn't mean the overall answer failed. Each retry attempt counts as its own step against the assistant mode's limit: if a tool keeps failing – for example because a connected service is currently down – that one tool alone can use up the entire step budget. The response then ends with ["Maximum number of agent steps reached"](/en/docs/platform/chat-errors#agent-max-iterations), even though it can feel like an infinite loop while it's happening – the assistant reliably stops there at the latest.

Memory is one of the basic tools – detailed under [Memory](#memory). For your own code, [Skills](#skills) are the next step.

### Knowledge – files and data pools

Gives the assistant access to static company knowledge – in two ways:

- **Upload files:** individual documents via drag and drop. Good for manageable, assistant-specific sets.
- **Connect a data pool (RAG search index):** larger knowledge volumes via a pre-indexed search index, maintained by admins. Unlike connectors, data pools don't deliver live data but search a prepared knowledge base.

For most teams, the data pool runs on the meinGPT Cloud and doesn't require a dedicated Outpost – more under [Data Sources (RAG)](/docs/integrations/data-pools-rag). A dedicated [Outpost](/docs/integrations/vault) is only needed for on-premise setups, for example with special security requirements. Unsure whether to use a connector or a data pool? See the [Integrations guide](/docs/integrations/data-integration-guide).

**Several or larger files take time.** Uploaded files need to be processed before the assistant can use them – with several or larger files, this can take noticeably long. If your set grows beyond a manageable, assistant-specific collection, a **data pool** is the better choice: it's built for large volumes and syncs in the background, so you don't have to wait for it to finish.

**Excel and CSV files are handled differently from Word files.** Uploaded Word documents are automatically included in every conversation once processed. Excel and CSV files are not automatically read in this way – the assistant has to actively decide to look them up. If the instructions don't say when and why to do so, the file can end up being silently skipped. State explicitly in the instructions when and for what the Excel or CSV file should be consulted.

**File upload limits:** Up to 50 files per assistant, each up to 50 MB. Supported formats include PDF, DOCX, PPTX, and XLSX. Older formats like **.doc**, **.xls**, and **.ppt** aren't supported – convert them to .docx, .xlsx, or .pptx first.

If an upload fails, meinGPT shows an error toast and the file won't appear in the knowledge list. Check the file size and format, then upload it again. If the problem persists, contact support with the error text shown.

### Advanced options – conversation starters & assistant mode

Two optional levers at the very bottom of the editor:

- **Conversation starters:** predefined opening messages offered when the assistant is opened (e.g. *"What is Apple's current stock price?"*). Add as many as you like via **Add another**.
- **Assistant mode:** controls how many tool calls the assistant makes at most per answer. Default: **up to 5 tool calls**. Higher values help with complex tasks but cost more time and credits.

![Advanced options: conversation starters and assistant mode](/images/assistants/assistants-edit-more-options-en.png)

### Assistant check

The **Assistant check** in the right sidebar checks live whether the basics are set: system prompt defined, description added, tools enabled, and knowledge sources linked. The detailed analysis also runs on **Save**.

![Assistant check in the sidebar](/images/assistants/assistants-edit-general-assistant-check-en.png)

## Memory and Skills: get more out of your assistant

Two optional features turn a simple assistant into a real helper. You can add either one later at any time.

### [Memory – long-term memory](#memory)

Your assistant remembers information about you across individual chats – personal and visible only to you.

### [Skills – custom capabilities](#skills)

Your own code in a secure sandbox: call APIs, generate files, process data.

### Memory

With **Memory**, your assistant remembers information about you across individual chats – e.g. your role, your working style, or fixed preferences. That way you don't have to re-explain recurring context every time.

Memory is **personal per user**. Your memories are tied to your account, not visible to others, and are not automatically shared with your team. They apply to **all your assistants** that have Memory enabled – what one assistant stores, another with Memory enabled can also use.

**Enabling:** Memory is a built-in tool and only works when it's switched on in the assistant. You enable it in the editor under **Tools → Basic tools**. If it's off, the assistant neither stores nor reads memories.

![Enable Memory under Basic tools](/images/assistants/memory-enable-tool-en.png)

**How it works:** Memory isn't loaded automatically into every chat. Instead, **the model decides for itself** when to use it:

- It **searches** your memories before answering a question that might depend on prior context.
- It **stores** a new memory when a stable preference or long-term context comes up.
- It **updates** an existing memory when you correct earlier information.

You see these actions directly in the chat as their own tool steps. The memory search itself works **semantically** – it finds relevant memories by meaning, not just exact word matches.

![Memory tool step in the chat](/images/assistants/memory-chat-toolcall-en.png)

**Managing:** you manage your memories centrally on the **Memory page in Settings**. There you can view, search, delete individually or together, remove everything via **Delete all**, or import from another AI.

![Memory page in Settings](/images/assistants/memory-settings-overview-en.png)

The assistant can **create, search, retrieve and update** memories – but **cannot delete** them. Deleting is up to you alone in Settings. A memory's content isn't edited there; to change it, delete it or have the assistant update it in the chat.

### Memory tool functions

When Memory is enabled, the assistant has these functions available:

| Function         | What it does                        |
| ---------------- | ----------------------------------- |
| `memory_add`     | Store a new memory                  |
| `memory_search`  | Search memories semantically        |
| `memory_get_all` | Retrieve all stored memories        |
| `memory_update`  | Update an existing memory           |

### Import memories from another AI

If you've already worked with ChatGPT, Gemini or Claude, you can bring over what they've stored about you. On the **Memory page in Settings**, open **Import**:

**Copy the prompt:** meinGPT gives you a ready-made prompt. Copy it and paste it into ChatGPT, Gemini or Claude.
**Paste the answer:** bring the other AI's answer back and paste it. meinGPT extracts the memories and sorts them by category (Profile, Working style, Current work, Team & contacts, Rules).
**Review and import:** go through the suggestions, uncheck anything you don't want, and finish via **Import memories**.

Only the selected memories are stored – up to **50 memories** per import.

### Best practices for Memory

- Store **stable preferences** and **long-term context** – not fleeting one-off details.
- Keep memories **short and self-contained** so they stay usable on their own.
- Don't store **secrets** or highly sensitive data (passwords, keys).
- Have existing memories **updated** on corrections instead of creating duplicates.

### Skills

**Skills** are reusable code packages (`.zip`) that give your assistant capabilities beyond plain prompting or knowledge access. They run in the **code sandbox** and can call external APIs, generate files, process data, or apply specialized logic.

In the editor, Skills are a **standalone section right below Knowledge** – not part of the Tools section, even though the two work together. They're only available when the code sandbox is active for your organization (on by default). If the Skills area is missing, ask an admin.

**When does a skill make sense?** When your assistant needs to:

- **call an API** for which there's no native connector (e.g. your internal contract-management system)
- **generate a file** with your layout (Word template, Excel report, PowerPoint with branding)
- **process data** in a format the model can't handle natively (e.g. parse binary data)
- **run deterministic logic** (calculations, validation, business rules)

If a system prompt plus knowledge/data pool and native tools is enough, you don't need a skill – skills are the next step up for **your own executable logic**.

**How to add a skill:** the Skills area sits in the editor as its own card, with a **Create skill** button top right and a drag-and-drop zone below. There are two ways:

![Skills area in the assistant editor](/images/assistants/assistants-neu-skills-de.png)

#### Way 1: Have a skill created via chat

Clicking **Create skill** doesn't open a wizard – it starts a normal new chat with your assistant, pre-filled with a first message: *"Create a new skill for this assistant."*

![The "Create skill" button in the Skills area](/images/skills/skills-create-chat-1-en.png)

**Send the message:** the pre-filled message is already in the input field – just send it.
**Answer the questions:** the assistant interviews you before writing code – the skill's purpose, required APIs, credentials, and whether an existing file should serve as a basis.
**Code is generated:** the assistant writes the package files (at least a `SKILL.md`) and builds a `.zip` from them.
**Attached automatically:** the finished package appears directly in the assistant's skills list – no manual upload needed.

![The assistant's follow-up questions after sending the message](/images/skills/skills-create-chat-2-en.png)

If the skill contains credentials (API keys, tokens), the assistant creates a `secrets.json` with placeholder values. You then enter the real values in the file explorer – they're never asked for or logged in the chat.

#### Way 2: Upload a ready-made `.zip`

If the skill already exists as a package, drag the `.zip` into the drop zone or click to select it.

![Upload a ready-made .zip via drag and drop](/images/skills/skills-upload-dropzone-en.png)

- **Limits:** up to 20 files at once, practical limit **50 MB per file**.
- **No structure check:** the platform only checks technical safety (no zip bomb). Whether a `SKILL.md` is included or the package is sensibly built is **not** validated – stick to the recommended structure below.

### Skill vs. tool vs. connector – a quick distinction

| Tool | What it is | When |
|---|---|---|
| **Native tool / connector** | Pre-built connection to standard services (Slack, Outlook, Salesforce …) | Standard integrations from the marketplace |
| **Skill** (`.zip`) | Your own code (Python or JS/TS) running in the sandbox | Custom logic, proprietary APIs, file generation in your own format |
| **Knowledge / data pool** | RAG over static documents | When the assistant should know your knowledge, not execute it |

### Structure of a skill package

A skill package is a `.zip` with a `SKILL.md` as instructions plus the code. Recommended structure:

```
my-skill/
├── SKILL.md
├── scripts/
│   ├── main.py
│   └── helpers.py
└── references/
    └── api-reference.md
```

The `SKILL.md` starts with a YAML frontmatter and is free-form Markdown after that:

| Field / section | Purpose |
|---|---|
| `name` | Short, descriptive name (lowercase, hyphenated) |
| `description` | When the assistant should use the skill – the text the model relies on |
| `license` (optional) | Usually `Proprietary` or `MIT` |
| Title (H1) | One-sentence summary |
| `## Rules` | What the assistant should do / avoid |
| `## Workflow` | Step-by-step flow |
| `## Good fits` | Concrete use cases |
| `## Avoid by default` | What the skill is **not** meant for |

If the `SKILL.md` gets too long (guideline: 500 lines), move detail into `references/`. The language (Python or JavaScript) is detected automatically – from markers like `requirements.txt` (Python) or `package.json` (JS). Without a clear marker, JavaScript is the default. So for a pure Python skill, include a `requirements.txt`, even if it stays empty.

### Security & sandbox

Skills run in an isolated sandbox:

- No direct access to the host system, no internet access from the skill code
- The language per skill is detected automatically on binding (Python or JS)
- Credentials live as `secrets.json` inside the package and aren't delivered to the model itself
- Resource limits prevent infinite loops or excessive memory use

Details under [Code Sandbox](/docs/platform/code-sandbox).

### Common uses

| Use case | Skill content |
|---|---|
| Generate offers in the company layout | Word template + Python script that inserts chat data |
| DATEV export from invoice data | JS script converting JSON to CSV |
| Connect to the internal CRM (no standard connector) | Python API client for your CRM |
| Structured PDF extraction from your own layout | Python with `pdfplumber` |
| Custom validation (e.g. tax calculations) | JS with your calculation logic |

**Formatting fidelity isn't guaranteed.** When filling a Word template, the skill carries over the template's existing styles – exact adherence to your brand guidelines isn't automatically checked. For brand-critical templates, spot-check the result.

### Editing & limits

Clicking a skill in the list opens the file explorer: file tree on the left (`SKILL.md` always on top), code editor on the right. You can view, edit, delete files and save changes back into the package.

![Skill file explorer](/images/skills/skills-file-explorer-en.png)

- **No version history:** saving overwrites the previous state permanently – keep your own copy before larger changes.
- **No sharing between assistants:** each skill belongs to exactly one assistant. To run the same skill on several assistants, upload the `.zip` to each one individually.
- **"Improve" often creates a new package:** if you ask the assistant to extend an existing skill, it often creates a new package – remove outdated duplicates manually.

## Using assistants
Once your assistant is saved, you can use, share, and manage it.

### Start a chat

There are several ways:

- Click the profile image under **Favorites**.
- Directly from the **Preview** top right on the editing page.
- Select it under **My assistants** and start with a conversation starter or your own message.
- In a general chat, pick an assistant via the **model selector** bottom right.

Clicking the card under **My assistants** starts a chat directly – the most common action.

### Edit an assistant

Since an assistant is used far more often than edited, clicking the card is reserved for starting a chat. You reach the configuration via the **three-dot menu (⋮)** on the card → **Edit assistant**. The menu only appears if you have edit rights; for assistants shared as **Can use**, it isn't available.

### Favorite

Click the **star** on the card. Favorited assistants appear in the **Favorites** area of the sidebar with their avatar – the chat is start-able with one click.

![Favorited assistants in the sidebar](/images/assistants/assistants-sidebar-favorites-en.png)

### Share

In two steps: click the **share icon** (on the card or in the editor top right), then search for people or teams and choose the access type:

- **Can use** – use it, but can't view or edit the configuration
- **Can view** – view it, but can't use or edit it
- **Can edit** – use, change, and manage its shares

Workspace admins can also share with **everyone in the workspace** (org-wide is limited to **Can use** or **Can view**). The dialog shows all active shares; removing the workspace-wide share must be confirmed.

![Share dialog with permissions](/images/assistants/assistants-share-assistant-context-en.png)

### Import via link

Assistants can be added via a shareable import link. Create links with the [Assistant Creator](https://assistant-creator.meingpt.com/). The import page supports the parameters `c` (compressed, recommended) and `p` (legacy). Details: [Assistant Creator](/docs/admin-guide/assistant-creator).

### Pin to the sidebar (admins)

Workspace admins can pin shared assistants to the **Apps area** of the sidebar – they then appear there as standalone chatbot apps. Pin via the **pin icon (📌)** in the card header or the editor toolbar; unpin via the same icon or the context menu. Pinned assistants remain visible only to people who already have access to them – normal permission checks still apply. Pinned assistants can only be deleted after unpinning.

### Delete

You'll find **Delete** in the **three-dot menu (⋮)** on the card. A confirmation dialog asks once more before the assistant is permanently removed.

If the assistant is pinned to the sidebar, the **Delete** entry is disabled – unpin it first via **Unpin from sidebar** (see above), only then can it be deleted.

A share (to people, teams, or the whole workspace) does not restrict deletion for you as the owner.

### Multiple languages

You can offer the same assistant to international teams in multiple languages without duplicating it: description, system prompt, and conversation starters can be stored translated. On opening, the variant in the workspace's or user's language is shown.

### Access via API

Via the meinGPT API you call assistants from your own applications or automations (e.g. Make). The **AssistantID** is in the browser URL in edit mode after `/assistants/` (e.g. `.../assistants/abc-123` → ID `abc-123`). Full reference: [Assistants API](/docs/api/assistants).

## If you want to go deeper

### [AI models](/docs/platform/models)

The available models and when to use which

### [Connectors](/docs/integrations/connectors)

Connect external services like Microsoft 365, Jira, or Salesforce

### [Code Sandbox](/docs/platform/code-sandbox)

How the execution environment for skills works in detail