# PROMPT
Source: https://docs.getcellm.com/api-reference/functions/prompt



Allows you to call the default model from a cell formula.

## Inputs

<ParamField type="string">
  Your prompt - the instructions for the model to follow.

  Can be a string, a cell reference, or a range of cells.
</ParamField>

<ParamField type="cell reference(s)">
  One or more cell references or ranges as context for your prompt (e.g., A1, B2:C3, D4).

  You can provide multiple separate cell references that will all be included as context.
</ParamField>

<ResponseField name="response" type="string">
  The model's response as plain text.
</ResponseField>

<Note>
  Temperature is configured via the ribbon UI. Use the Temperature dropdown in the Model section. This can be either:

  * A number between 0.0 and 1.0
  * A preset string:
    * `"Consistent"` (0.0) - Deterministic output, same result each time
    * `"Neutral"` (0.3) - Balanced between consistency and variety
    * `"Creative"` (0.7) - More varied and creative outputs

  Lower values (closer to 0) produce consistent, deterministic responses. Higher values (closer to 1) produce more varied, creative responses.
</Note>

<RequestExample>
  ```excel Text Instructions theme={null}
  =PROMPT("Extract keywords")
  ```

  ```excel Cell Instructions theme={null}
  =PROMPT(A1:D10)
  ```

  ```excel With Context theme={null}
  =PROMPT("Extract keywords", A1:D10)
  ```

  ```excel Multiple Cell Ranges theme={null}
  =PROMPT("Compare these datasets", A1:B10, D1:E10)
  ```

  ```excel Mixed Cell References theme={null}
  =PROMPT("Analyze all data", A1, B2:C5, D6)
  ```
</RequestExample>

<ResponseExample>
  ```excel TOROW theme={null}
  =PROMPT.TOROW("Extract keywords", A1:D10)
  ```

  ```excel TOCOLUMN theme={null}
  =PROMPT.TOCOLUMN("Extract keywords", A1:D10)
  ```

  ```excel TORANGE theme={null}
  =PROMPT.TORANGE("Extract keywords", A1:D10)
  ```
</ResponseExample>


# PROMPTMODEL
Source: https://docs.getcellm.com/api-reference/functions/prompt-model



Allows you to call a model from a cell formula and specify the model as the first argument. This overrides the default model.

## Arguments

<ParamField type="string">
  A string on the form "provider/model" (e.g., "openai/gpt-5.4-mini").

  The default model is determined by your configuration settings.
</ParamField>

<ParamField type="string">
  Your prompt - the instructions for the model to follow.

  Can be a string, a cell reference, or a range of cells.
</ParamField>

<ParamField type="cell reference(s)">
  One or more cell references or ranges as context for your prompt (e.g., A1, B2:C3, D4).

  You can provide multiple separate cell references that will all be included as context.
</ParamField>

## Returns

<ResponseField name="response" type="string">
  The model's response as plain text.
</ResponseField>

<Note>
  Temperature is configured via the ribbon UI. Use the Temperature dropdown in the Model section. This can be either:

  * A number between 0.0 and 1.0
  * A preset string:
    * `"Consistent"` (0.0) - Deterministic output, same result each time
    * `"Neutral"` (0.3) - Balanced between consistency and variety
    * `"Creative"` (0.7) - More varied and creative outputs

  Lower values (closer to 0) produce consistent, deterministic responses. Higher values (closer to 1) produce more varied, creative responses.
</Note>

<RequestExample>
  ```excel Text Instructions theme={null}
  =PROMPTMODEL("openai/gpt-5.4-mini", "Extract keywords")
  ```

  ```excel Cell Instructions theme={null}
  =PROMPTMODEL("openai/gpt-5.4-mini", A1:D10)
  ```

  ```excel With Context theme={null}
  =PROMPTMODEL("openai/gpt-5.4-mini", "Extract keywords", A1:D10)
  ```

  ```excel Multiple Cell Ranges theme={null}
  =PROMPTMODEL("openai/gpt-5.4-mini", "Compare these datasets", A1:B10, D1:E10)
  ```

  ```excel Mixed Cell References theme={null}
  =PROMPTMODEL("openai/gpt-5.4-mini", "Analyze all data", A1, B2:C5, D6)
  ```
</RequestExample>

<ResponseExample>
  ```excel TOROW theme={null}
  =PROMPTMODEL.TOROW("openai/gpt-5.4-mini", "Extract keywords", A1:D10)
  ```

  ```excel TOCOLUMN theme={null}
  =PROMPTMODEL.TOCOLUMN("openai/gpt-5.4-mini", "Extract keywords", A1:D10)
  ```

  ```excel TORANGE theme={null}
  =PROMPTMODEL.TORANGE("openai/gpt-5.4-mini", "Extract keywords", A1:D10)
  ```
</ResponseExample>


# File Reader
Source: https://docs.getcellm.com/api-reference/tools/file-reader



Reads a file and returns its content as plain text.

## Parameters

<ParamField type="string">
  An absolute path to a file on your disk.

  ```mdx Example path theme={null}
  C:\Users\username\Documents\report.pdf
  ```

  Supports extensions: c, cpp, cs, csv, cxx, h, hxx, html, java, json, jsonl, md, pdf, php, py, rb, txt, and xml.
</ParamField>

## Returns

<ResponseField name="content" type="string">
  The content of the file as plain text.
</ResponseField>

<Info>
  This tool is automatically used by the AI model when needed. You enable it in Cellm's ribbon menu, then simply ask the model to perform tasks that require reading files (e.g., "Summarize the content of report.pdf in my Documents folder").
</Info>

<RequestExample>
  ```excel Read and summarize theme={null}
  =PROMPT("Read and summarize C:\Users\username\Documents\report.pdf")
  ```
</RequestExample>

<ResponseExample>
  ```excel With cell reference theme={null}
  =PROMPT("Read and summarize this file", A1)
  ```

  Where A1 contains: `C:\Users\username\Documents\report.pdf`
</ResponseExample>


# File Search
Source: https://docs.getcellm.com/api-reference/tools/file-search



Uses glob patterns to search for files on your disk and returns matching file paths.

## Parameters

<ParamField type="string">
  The root directory to start the glob search from. Example: `C:\Users\username\Documents`
</ParamField>

<ParamField type="string[]">
  Patterns to match files you want to find. Use absolute paths with wildcards. Common examples:

  * `C:\Users\username\Documents\*.pdf` - All PDF files in Documents
  * `C:\Users\username\Downloads\*.xlsx` - All Excel files in Downloads
  * `C:\Projects\**\report*.docx` - Word files starting with "report" in Projects and all subfolders
  * `C:\Data\2024-*.csv` - CSV files starting with "2024-" in Data folder
</ParamField>

<ParamField type="string[]">
  Patterns to exclude files from results. Use absolute paths with wildcards. Common examples:

  * `C:\Users\username\Documents\*temp*` - Exclude files with "temp" in the name
  * `C:\Users\username\Documents\*.bak` - Exclude backup files
  * `C:\Projects\**\.git\**` - Exclude files in .git folders
  * `C:\Users\username\Documents\*draft*` - Exclude files with "draft" in the name
</ParamField>

## Returns

<ResponseField name="filePaths" type="string[]">
  A list of file paths that match the include patterns and don't match the exclude patterns.
</ResponseField>

<Info>
  This tool is automatically used by the AI model when needed. You enable it in Cellm's ribbon menu, then simply ask the model to perform tasks that require file operations (e.g., "Find all PDF files in my Documents folder").
</Info>

<RequestExample>
  ```excel Find PDF files theme={null}
  =PROMPT("Find all PDF files in C:\Users\username\Documents")
  ```

  ```excel Find CSV files excluding temporary theme={null}
  =PROMPT("Find all CSV files in C:\Users\username\Downloads, but exclude any files with 'temp' or 'draft' in the name")
  ```
</RequestExample>

<ResponseExample>
  ```excel With cell reference theme={null}
  =PROMPT("Find all PDF files in this folder", A1)
  ```

  Where A1 contains: `C:\Users\username\Documents`
</ResponseExample>


# Development
Source: https://docs.getcellm.com/get-started/development

Get started with Cellm development and contributions

This guide will walk you through the build process step by step.

## Build with command line

1. Clone this repository:
   ```cmd theme={null}
   git clone https://github.com/getcellm/cellm.git
   ```

2. In your terminal, navigate to the root of the project directory:
   ```cmd theme={null}
   cd cellm
   ```

3. Install dependencies:
   ```cmd theme={null}
   dotnet restore
   ```

4. Build the project:
   ```cmd theme={null}
   dotnet build --configuration Debug
   ```

Once the build is complete, you load Cellm into Excel:

1. Navigate to the output folder `src/Cellm/bin/net9.0-windows/publish/`

2. Double-click `Cellm-AddIn64-packed.xll`

Excel will open with Cellm ready to use test.

### Troubleshooting

If the build fails, here are some common things you can try:

* Make sure you have .NET 9.0 SDK installed (not just the runtime). You can verify your .NET installation by running dotnet --version in your terminal.
* Try running `dotnet clean` followed by `dotnet restore` and `dotnet build` again.
* Check that you're in the correct directory (cellm folder).

## Build with Visual Studio

1. In Visual Studio, go to File > Clone Repository.

2. Set the Repository Location to `https://github.com/getcellm/cellm`, the Path to a directory of your choice, and click Clone.

3. Run the "Excel" configuration. Visual Studio will build Cellm and open Excel. Click on "Enable this add-in for this session only" to load the build into Excel.

All Visual Studio's usual debugging tools works when you run the "Excel" configuration. You can set breakpoints, inspect runtime variables, and view log messages in the Output window.

## Build the installer

1. Copy `src/Cellm.Installers/Cellm.Installer.wixproj.user.sign` to `src/Cellm.Installers/Cellm.Installer.wixproj.user` and set `CERTIFICATE_PATH` and `CERTIFICATE_PATH`. Don't just rename the file. It is tracked by git and you risk committing your sensitive information later.

2. In Visual Studio, select the `Release` configuration and build the `Cellm.Installer` target.

You need the Windows 10 SDK or Windows 11 SDK which includes the sign tool. If you get errors about `signtool.exe` not being found, run the Visual Studio Installer and modify your Visual Studio installation to include one of these SDKs.

## Contributing

We welcome contributions to Cellm! This section will guide you through the process.

1. Fork the repository on GitHub
2. Create a new branch from `main` for your feature or bug fix:
   ```cmd theme={null}
   git checkout -b your-feature-name
   ```
3. Make your changes.
4. Commit your changes with clear, descriptive commit messages with [Conventional Commits](https://gist.github.com/qoomon/5dfcdf8eec66a051ecd85625518cfd13) prefixes (fix, feat, docs, refactor):
   ```cmd theme={null}
   git commit -m "feat: descriptive message"
   ```
5. Push your branch to your fork:
   ```cmd theme={null}
   git push origin your-feature-name
   ```
6. Open a Pull Request (PR) against our `main` branch

### Contributor License Agreement (CLA)

You must sign our [Contributor License Agreement (CLA)](https://github.com/getcellm/cellm/blob/main/CLA.md). This is a one-time requirement that grants us the necessary rights to use your contributions. The CLA signing process will be automatically initiated when you submit your first PR. Our bot will guide you through the process.

### Getting Help

If you have questions about contributing:

* Open a GitHub issue for bug reports or feature discussions
* Check existing issues and PRs to avoid duplicates
* Join our community discussions in [Discord](https://discord.gg/zApxYpe2ZW) for general questions

We review or respond to all PRs.


# Install
Source: https://docs.getcellm.com/get-started/install

Add Cellm to Excel

This guide will walk you through installing Cellm and getting it ready to use in Excel. The whole process takes about 10 minutes.

## Requirements

Before installing Cellm, you'll need Windows 10 or higher, Excel 2010 or higher, and the .NET 9.0 Runtime on your computer.

<AccordionGroup>
  <Accordion icon="file-excel" title="Install Excel">
    1. Open "Microsoft Store" on your computer and search for "Microsoft 365"
    2. Click "Install" and follow the install procedure. Requires a Microsoft 365 subscription.
  </Accordion>

  <Accordion icon="desktop" title="Install .NET 9.0 Runtime">
    1. Go to [https://dotnet.microsoft.com/en-us/download/dotnet/9.0](https://dotnet.microsoft.com/en-us/download/dotnet/9.0).
    2. In the ".NET Runtime" table, find the "Windows" row and "Installers" column  and click on `x64` to download the installer.
    3. Run the installer.
  </Accordion>
</AccordionGroup>

## Install

To install Cellm:

<Steps>
  <Step title="Download the installer">
    Go to the [Github Release page](https://github.com/getcellm/cellm/releases) and download the latest `Cellm-AddIn-Release-x64.msi`
  </Step>

  <Step title="Run the installer">
    Run the installer and follow the prompts.
  </Step>
</Steps>

<AccordionGroup>
  <Accordion icon="message-bot" title="Install Ollama to use local models (optional)">
    <Info>
      If you want to use the more powerful hosted models right away, you can skip this step. The [Hosted Models](/models/hosted-models) section shows you how.
    </Info>

    To get started with local models, we recommend you try out the Gemma 4 E4B model. Gemma 4 E4B is a wonderful little model that will run fine on your CPU, ensuring no data ever leaves your computer. And it's free.

    1. Download and install [Ollama](https://ollama.com/). Ollama will start after the install and automatically run whenever you start up your computer.
    2. When you select an Ollama model in Cellm, it will prompt you to download it automatically. Alternatively, open the Windows Terminal, type `ollama pull gemma4:e4b` and hit Enter.
    3. Open Excel and type `=PROMPT("What model are you and who made you?")`. The model will respond that it is Gemma 4 and made by Google.
  </Accordion>

  <Accordion icon="plug" title="Enable MCP (optional)">
    MCP lets AI models use external tools like web browsers, file systems, CRM systems, and databases. To use MCP servers and tools, you may need to install:

    **Node.js** (to run Node.js-based MCP servers):

    1. Go to [nodejs.org](https://nodejs.org)
    2. Download the LTS version installer for Windows
    3. Run the installer and follow the prompts
    4. Verify installation by opening Windows Terminal and typing `node --version`

    **uv** (to run Python-based MCP servers):

    1. Open Windows Terminal
    2. Run: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`
    3. Verify installation by typing `uv --version`

    **Playwright dependencies** (for the built-in Internet Browser tool):

    1. After installing Node.js, open Windows Terminal
    2. Run: `npx playwright install --with-deps`

    <Info>
      Node.js and uv are runtimes that let you run MCP servers on your computer. Playwright is a specific built-in tool for browser automation. HTTP-based MCP servers run remotely and don't require any installations.
    </Info>
  </Accordion>
</AccordionGroup>

## Upgrade

When a new version of Cellm is released, simply repeat the installation steps above with the latest installer.

## Uninstall

If you ever need to remove Cellm from your computer:

<Steps>
  <Step title="Open Add or Remove programs">
    Search for "Add or remove programs" in the Windows start menu and open it.
  </Step>

  <Step title="Uninstall Cellm">
    Select "Cellm" from the list and click "Uninstall".
  </Step>
</Steps>

## You're all set!

Cellm is now installed and ready to use. Open Excel and look for the new **Cellm** tab in the ribbon menu. From there, you can start using AI in your spreadsheets.

## Next steps

<CardGroup>
  <Card title="Prompting" icon="text" href="/usage/prompting">
    Learn how to use Cellm to automate repetitive tasks in Excel.
  </Card>

  <Card title="Function Calling" icon="function" href="/usage/function-calling">
    Learn how to use Excel as a low-code task orchestrator by enabling Cellm to access external tools and data.
  </Card>

  <Card title="Local Models" icon="server" href="/models/local-models">
    Learn how to run models on your own computer. No data ever leaves your machine. And it's free.
  </Card>

  <Card title="Hosted Models" icon="network-wired" href="/models/hosted-models">
    Learn how to bring your own API key (BOYK) and use models from Anthropic, OpenAI, and others.
  </Card>
</CardGroup>


# Overview
Source: https://docs.getcellm.com/get-started/overview

Use LLMs in Excel formulas

## What is Cellm?

Cellm is an Excel extension that lets you use Large Language Models (LLMs) in cell formulas. Cellm is useful when you want to use AI for repetitive tasks that would normally require copy-pasting data in and out of a chat window many times.

For example, you can write `=PROMPT("Extract all person names mentioned in the text", A1)` in a formula and drag the cell to apply the prompt to many rows. Cellm's `=PROMPT()` function will output the AI response to a range of text, similar to how Excel's =SUM() function outputs the sum of a range of numbers.

<Frame>
  <img />
</Frame>

## Get Started

If you're new to Cellm, you can get started using the guides below.

<CardGroup>
  <Card title="Install" icon="download" href="/get-started/install">
    Get started with Cellm in minutes, by downloading and adding it to Excel.
  </Card>

  <Card title="Quickstart" icon="rocket" href="/get-started/quickstart">
    Learn how to use AI in Excel and quickly apply prompts to thousands of rows.
  </Card>
</CardGroup>

## Usage

Cellm has a small set of core features that seamlessly integrates with Excel workflows. Use the links below to learn more about what Cellm can do.

<CardGroup>
  <Card title="Writing Prompts" icon="text" href="/usage/writing-prompts">
    Learn how to use Cellm to automate repetitive tasks in Excel.
  </Card>

  <Card title="Calling Functions" icon="function" href="/usage/calling-functions">
    Learn how to use Excel as a low-code task orchestrator by enabling Cellm to access external tools and data.
  </Card>

  <Card title="Local Models" icon="server" href="/models/local-models">
    Learn how to run models on your own computer. No data ever leaves your machine. And it's free.
  </Card>

  <Card title="Hosted Models" icon="network-wired" href="/models/hosted-models">
    Learn how to bring your own API key (BOYK) and use models from Anthropic, OpenAI, and others.
  </Card>
</CardGroup>

## Where did Cellm come from?

A friend of ours was writing a systematic review paper. She had to compare 7,500 papers against inclusion and exclusion criterias. We figured this was a great use case for LLMs but quickly realized that individually copying 7,500 papers in and out of chat windows was a total pain. This sparked the idea to make an AI tool to automate repetitive tasks for people like her who would rather avoid programming.

We think Cellm is really cool because it enables everyone to automate repetitive tasks with AI to a level that was previously available only to programmers.

## How does it work?

Cellm adds a few fundamental features to Excel that you can use to combine AI text processing with normal Excel functions:

* Call AI models with the `=PROMPT()` function that outputs model responses directly in cells.
* `=PROMPT()` behaves like a normal Excel function. Prompts can reference other cells, re-run when inputs change, and outputs can be filtered, plotted, and used in other Excel formulas.
* Outputs with multiple values can spill into rows and colums, making it easy to build workflows that batch process your data.
* Cellm supports models from Anthropic, AWS, Azure, Google, Mistral, OpenAI, and others as well as local models via Llamafiles, Ollama, or vLLM.

## How do I get started?

You [download the installer](https://github.com/getcellm/cellm/releases/download/v0.4.0/Cellm-AddIn-Release-x64.msi) and run it. Cellm will be available the next time you start Excel. As Cellm is just an Excel add-in, its extremely easy to get started. If you know how to use Excel's `=SUM()` function, you will quickly get the hang of Cellm's `=PROMPT()` function.

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/get-started/quickstart">
    Get started with Cellm in minutes, by downloading and adding it to Excel.
  </Card>

  <Card title="Prompting" icon="text" href="/usage/prompting">
    Learn how to use AI in Excel and quickly apply prompts to thousands of rows.
  </Card>
</CardGroup>


# Quickstart
Source: https://docs.getcellm.com/get-started/quickstart

Get up and running with Cellm in minutes

## Install

To get started, you can quickly install Cellm and a local model:

<Steps>
  <Step title="Download Cellm">
    Go to the [Github Release page](https://github.com/getcellm/cellm/releases) and download the latest `Cellm-AddIn-Release-x64.msi`
  </Step>

  <Step title="Install Cellm">
    Run the installer to install Cellm on your computer.
  </Step>

  <Step title="Install Ollama">
    Download and install [Ollama](https://ollama.com/) to run local AI models.
  </Step>

  <Step title="Download Gemma 4 model">
    When you select an Ollama model in Cellm, it will prompt you to download it automatically. Alternatively, open the Windows Terminal and type `ollama pull gemma4:e4b` to download the Gemma 4 E4B model.
  </Step>
</Steps>

<Info>
  Cellm requires Windows 10 or higher, [Excel 2010 or higher](https://www.microsoft.com/en-us/microsoft-365/excel) (must be desktop app), and the [.NET 9.0 Runtime](https://dotnet.microsoft.com/en-us/download/dotnet/9.0). See the [Install](install.mdx) page for details.
</Info>

## Cellm Ribbon

After installation, open Excel and look for the new **Cellm** tab in the ribbon menu. Use this tab to configure Cellm:

<Frame>
  <img />
</Frame>

The ribbon has four main sections that control how Cellm works:

<AccordionGroup>
  <Accordion icon="user" title="Account">
    **Manage your Cellm account**

    * **Login/Logout**: Log in to your Cellm account to use the Cellm provider, which handles model costs through your subscription
    * **Create Account**: Sign up for a Cellm account to access all features
    * **Manage Account**: Access your account settings
  </Accordion>

  <Accordion icon="message" title="Prompt">
    **Insert PROMPT formulas with different output shapes**

    Click these buttons to insert a `=PROMPT()` formula in the active cell and open the function wizard:

    * **Cell**: Output to a single cell (default)
    * **Row**: Spill multiple values across cells to the right with `=PROMPT.TOROW()`
    * **Column**: Spill multiple values down with `=PROMPT.TOCOLUMN()`
    * **Range**: Let the model decide the output shape with `=PROMPT.TORANGE()`

    If the active cell already contains a PROMPT formula, clicking these buttons changes the output shape while keeping your arguments.
  </Accordion>

  <Accordion icon="brain" title="Model">
    **Configure which AI model to use and how**

    * **Provider**: Select your model provider (OpenAI, Anthropic, Ollama, etc.). Click the provider icon to configure API keys and base URLs
    * **Model**: Choose from preset models or type a custom model name
    * **Temperature**: Control randomness (Consistent/0.0, Neutral/0.3, Creative/0.7, or any value 0.0-1.0)
    * **Usage**: View input/output tokens and prompt counts for this session
    * **Speed**: See average Tokens Per Second (TPS) and Requests Per Second (RPS)
    * **Memory**: Toggle response caching. When on, identical prompts return cached results instantly, saving costs
  </Accordion>

  <Accordion icon="wrench" title="Tools">
    **Enable tools that extend model capabilities**

    * **Functions**: Built-in tools the model can use:
      * **Internet Browser**: Let models browse the web
      * **File Search**: Let models search for files on your computer
      * **File Reader**: Let models read PDF, Markdown, and text files

    * **MCP**: Add, configure, or remove Model Context Protocol servers for advanced integrations
  </Accordion>
</AccordionGroup>

## Usage

### Sending a prompt to a model

Sending prompts to a model is easy. Select a cell and type in its formula:

```mdx Text instruction theme={null}
=PROMPT("Extract the main topic from: The quarterly sales report shows a 15% increase in revenue across all departments")
```

The model will tell you that the main topic is sales.

### Combine your prompt with data from your spreadsheet

You augment your prompt with data from your spreadsheet by referencing cells in the prompt formula. . For example, try to copy a news article into cell A1 and type in the formula of cell B1:

```mdx Single cell context theme={null}
=PROMPT("Extract all person names mentioned in the text", A1)
```

The model will output person names in the news article in A1.

Try to copy another news article into cell A1 and hit enter. Watch how the formula recalculates. `=PROMPT()` formulas behave like any other built-in Excel function and re-run when its inputs change.

You can also use cell references to dynamically change your prompts. For example, try to fill many news articles into column A and then drag the fill handle of B1 down across many rows. Cellm will automatically send each article to the model and output the results in corresponding cells in column B.

You can reference a group of cells using standard Excel notation (this is called a "range"):

```mdx Range context theme={null}
=PROMPT("Extract all person names in the cells", A1:F10)
```

You can also reference multiple separate cell ranges:

```mdx Multiple ranges theme={null}
=PROMPT("Compare the data in these two tables", A1:C10, E1:G10)
```

### Spilling model response across multiple cells

You can use the `=PROMPT.TOCOLUMN()` function to spill the model response across multiple cells. For example, if you have text in cell A1, you can type in cell B1:

```mdx Spill to column theme={null}
=PROMPT.TOCOLUMN("Generate 10 relevant hashtags", A1)
```

This will put values in separate cells below.

<Frame>
  <img />
</Frame>

You can also use `=PROMPT.TOROW()` to spill the response across cells to the right or `=PROMPT.TORANGE()` to let the model choose whether to spill multiple values (if any) across rows and/or columns or not.

<Warning>
  If you wish to combine multi-value output with function calling, you must use OpenAI as no other provider supports combining structured output with function calling.
</Warning>

### Function calling

Beyond basic text processing, you can use "Function Calling" to give models access to external tools and data and even take action in other systems. For example, expand the "Functions" menu in the Cellm ribbon tab, and click on "File Search" to enable the model to search for files on your computer. Then type:

```mdx With function calling theme={null}
=PROMPT("Which pdf files do I have in C:\Users\username\Downloads?")
```

<Tip>
  Gemma 4 E4B does not support function calling. For function calling you must use another model, e.g. OpenAI's `gpt-5.4-mini`.
</Tip>

## Next steps

<CardGroup>
  <Card title="Prompting" icon="pen-to-square" href="/usage/prompting">
    Learn more about prompting techniques and building automated workflows.
  </Card>

  <Card title="Breaking Down Tasks for AI" icon="lightbulb" href="/usage/breaking-down-tasks">
    Learn how to split a complex task into multiple smaller ones and select the right model for your tasks' complexity.
  </Card>

  <Card title="Function Calling" icon="image" href="/usage/function-calling">
    Use Excel as a low-code task orchestrator by enabling Cellm to access external tools and data.
  </Card>
</CardGroup>


# Choosing Model
Source: https://docs.getcellm.com/models/choosing-model

How to select the right model and break down tasks

Cellm supports hosted models that run in the cloud and local models that run on your computer. This page shows you how to choose the right model for your task and when to break down complex tasks into simpler ones.

## Model Sizes

In general, smaller models are faster and less intelligent, while larger models are slower and more intelligent. It's important to find the right balance for your task, because speed impact your productivity and intelligence impact your results. You should try out different models and choose the smallest one that gives you good results.

Cellm provides three preconfigured model sizes for most providers:

|                 | Small Model                                                  | Medium Model                                                 | Large Model                                                  |
| --------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| Speed           | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| Intelligence    | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| World Knowledge | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |

Small models are sufficient for many common tasks such as categorizing text or extracting person names from news articles. Medium models are appropriate for more complex tasks such as document review, survey analysis, or tasks involving function calling. Large models are needed for web browsing, tasks that require nuanced language understanding such as spam detection, or tasks that rely on the model's own world knowledge.

## Task Complexity

Your productivity with Cellm depends on your ability to find the sweet spot between task complexity and model size.

If a task is too complex or broad for your chosen model, it may hallucinate results and you should choose a larger model or break down your task in a sequence of simpler ones. But if your task is broken down into excessively simple prompts, you're not using the models' capabilities effectively and you may end up running needlessly many prompts which hurt your productivity and costs more money.

Here are some practical examples:

<Tabs>
  <Tab title="Too complex" icon="fire">
    Risk of unreliable results and output that is not suited for a single cell:

    ```mdx Too complex theme={null}
    =PROMPT("Analyze these customer reviews, identify all product defects, and output a list of engineering improvements", A1)
    ```
  </Tab>

  <Tab title="Balanced" icon="check">
    ```mdx Sentiment classification theme={null}
    =PROMPT("Classify the sentiment of the text in this cell as Positive, Negative, or Neutral", A1)
    ```

    ```mdx Product categorization theme={null}
    =PROMPT("Categorize this product review as Electronics, Clothing, or Home", A1)
    ```

    ```mdx Spam detection theme={null}
    =PROMPT("Detect if the email in this cell is spam or not spam", A1)
    ```

    ```mdx Date extraction theme={null}
    =PROMPT("Extract the invoice date from the PDF file", A1)
    ```

    ```mdx Name extraction theme={null}
    =PROMPT.TOROW("Extract all person names mentioned in the text in this cell", A1)
    ```
  </Tab>

  <Tab title="Too simple" icon="circle-xmark">
    Tasks that could be combined with more specific instructions:

    ```mdx Too simple theme={null}
    =PROMPT("Summarize this customer review.", A1)
    ```

    Consider adding classification or extraction in the same prompt.
  </Tab>
</Tabs>

Finding the right combination of task complexity and model size requires experimentation. In general, start out with a small or medium model and move to a large model if you are not happy with results. If a large model still gives you bad results, move on to breaking down your tasks into simpler ones.

## Breaking down tasks

When faced with a complex task or a task with various outputs, break it down into a sequence of smaller prompts. This makes it easier for the AI to help you, and for you to review the results at each step.

<Tip>
  It is faster to switch to a more powerful model than to break down tasks.
</Tip>

### Example

Imagine you want to analyze customer feedback from column A. Instead of a single, complex prompt, you can create a sequence of tasks and delegate some of them to models of appropriate size:

1. Translate: In column B, use the default model to translate into your own language.
   ```mdx Translate theme={null}
   =PROMPT("Translate to english", A2)
   ```

2. Classify Sentiment: In column C, use the default model to classify the feedback.
   ```mdx Classify sentiment theme={null}
   =PROMPT("Classify this feedback as 'Positive', 'Negative', or 'Neutral'.", B2)
   ```

3. Extract Suggestions: In column D, use a Large model to analyze the feedback and suggest improvements. You could also add relevant background information on your product directly to the prompt or to a cell that you reference.
   ```mdx Analyze feedback theme={null}
   =PROMPTMODEL("openai/gpt-5.4-mini", "Analyze user feedback and suggest improvements.", B2)
   ```

4. Extract Topics: In column E, extract relevant topics with a small model, which is efficient for simple extraction tasks.
   ```mdx Extract topics theme={null}
   =PROMPTMODEL.TOROW("openai/gpt-5.4-mini", "Extract relevant software engineering topics, such as UX, Bug, Documentation, or Improvement.", B2)
   ```

This approach gives you reliable results and granular control of the output format.

## What models can and cannot do

Understanding model capabilities helps you avoid common pitfalls.

**Use models to:**

* Extract data from text (names, dates, product codes)
* Classify and categorize data at scale
* Transform data (translate, summarize, reformat)
* Generate text variations

**Don't rely on models for:**

* Critical decisions without review. Models make mistakes with ambiguous data
* Current information. Models only know what you tell them or what they can access through tools
* Expert judgment. Use models for repetitive work, not in place of your domain knowledge

<Tip>
  Enable Internet Browser to let models fetch current data from the web. This requires a Large model.
</Tip>

## Best practices

**Be specific in your instructions**

* Tell the model exactly what you want and in what format
* Models only know what you tell them. Provide context or enable Internet Browser for external knowledge

**Use separate columns for multi-step tasks**

* Don't overload a single prompt with multiple tasks
* Each column should handle one clear step
* Example: Extract company name (column B) → Find industry (column C) → Summarize business (column D)

**Match model size to task complexity**

* Start with Small models for simple extraction and classification
* Use Medium models when Small models give inconsistent results
* Switch to Large models only when needed for complex reasoning

**Iterate on your prompts**

* Inconsistent results? Make your prompt more specific or add examples
* Bad results? Try a larger model or break the task down further

**Verify model output**

* Test on 5-10 examples before processing thousands of rows
* Review outputs before using them in reports or decisions


# Hosted Models
Source: https://docs.getcellm.com/models/hosted-models

How to use hosted models

> **See also:** [Breaking Down Tasks for AI](/usage/breaking-down-tasks) for practical advice on model selection and structuring your tasks.

Cellm supports hosted models from Anthropic, AWS, Azure, DeepSeek, Google, OpenAI, Mistral, and any OpenAI-compatible cloud provider. These models are more powerful than anything you can run on your own computer.

<Warning>
  AI providers use data from free tiers and even some consumer plans to improve their models. Review each provider's data usage policies before sending sensitive information. For data privacy guarantees, consider [local models](/models/local-models) or [Cellm's subscription plans](https://getcellm.com/pricing).
</Warning>

## Model sizes

We split hosted models into three tiers based on their size and capabilities, balancing speed, intelligence, and problem-solving skills:

|                   | Small Model                                                  | Medium Model                                                 | Large Model                                                  |
| ----------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| Speed             | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| Intelligence      | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| World Knowledge   | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| Recommended model | Gemini 3.1 Flash Lite                                        | Gemini 3 Flash                                               | Claude Opus 4.6                                              |

## Provider setup

To use hosted models, you need an API key from your chosen provider. Below are setup instructions for the most popular providers.

### Mistral (Recommended - Free Tier)

Mistral offers a generous free tier with access to powerful models.

<Steps>
  <Step title="Create an account">
    Go to [console.mistral.ai](https://console.mistral.ai) and sign up. Check your inbox and verify your email.
  </Step>

  <Step title="Select a plan">
    Choose between "Experiment" (free tier) or "Scale" (pay-as-you-go). The free Experiment tier offers generous usage limits.
  </Step>

  <Step title="Activate billing">
    Navigate to your Organization settings at [admin.mistral.ai](https://admin.mistral.ai) and add payment information. This activates your API keys even if you're using the free tier.
  </Step>

  <Step title="Create API key">
    Under the "Workspace" tab, go to "API Keys" and click "Create new key". Give your key a name and set an expiration date, then click "Create".
  </Step>

  <Step title="Save your key">
    Copy the key immediately and store it securely - you won't be able to see it again.
  </Step>

  <Step title="Configure in Cellm">
    In Excel, open Cellm's ribbon menu, select the `mistral` provider, click the provider icon, and paste your API key. Try a model like:

    ```mdx Mistral example theme={null}
    =PROMPTMODEL("mistral/mistral-small-latest", "Summarize customer feedback", A1)
    ```

    And go nuts.
  </Step>
</Steps>

<Tip>
  Mistral's free tier is excellent for getting started - you get significant usage before incurring costs.
</Tip>

### OpenAI

OpenAI provides access to GPT models, including GPT-5.4 and GPT-5.4-mini.

<Steps>
  <Step title="Create an account">
    Go to [platform.openai.com](https://platform.openai.com) and sign up or sign in.
  </Step>

  <Step title="Add payment method">
    OpenAI requires a payment method to use the API. Click "Start building" and add your payment details to purchase API credits.
  </Step>

  <Step title="Create API key">
    Click your profile icon in the top-right, select "View API keys", then click "Create new secret key". Copy the key immediately - you won't be able to see it again.
  </Step>

  <Step title="Configure in Cellm">
    In Excel, open Cellm's ribbon menu, select the `openai` provider, click the provider icon, and paste your API key. Try a model like:

    ```mdx OpenAI example theme={null}
    =PROMPTMODEL("openai/gpt-5.4-mini", "Classify sentiment as positive, neutral, or negative", A1)
    ```
  </Step>
</Steps>

<Info>
  OpenAI no longer provides free trial credits, so you'll need to add funds before making API calls.
</Info>

### Google Gemini

Google Gemini offers powerful AI models with a generous free tier.

<Steps>
  <Step title="Access Google AI Studio">
    Go to [ai.google.dev](https://ai.google.dev) and sign in with your Google account.
  </Step>

  <Step title="Get API key">
    Click "Get API key" in the left sidebar, then click "Create API key". Select an existing Google Cloud project or create a new one.
  </Step>

  <Step title="Save your key">
    Copy the generated API key and store it securely.
  </Step>

  <Step title="Configure in Cellm">
    In Excel, open Cellm's ribbon menu, select the `gemini` provider, click the provider icon, and paste your API key. Try a model like:

    ```mdx Gemini example theme={null}
    =PROMPTMODEL("gemini/gemini-3-flash-preview", "Extract person names from text", A1)
    ```
  </Step>
</Steps>

<Tip>
  Google Gemini offers 1,500 requests per day on the free tier, making it excellent for testing and development.
</Tip>

### Anthropic (Claude)

Anthropic provides Claude models, known for their strong reasoning capabilities.

<Steps>
  <Step title="Create an account">
    Go to [console.anthropic.com](https://console.anthropic.com) and sign up. Click "Start Building" to access the console.
  </Step>

  <Step title="Set up billing">
    Add a payment method to purchase credits. Anthropic offers free credits for new accounts.
  </Step>

  <Step title="Create API key">
    Navigate to "API Keys" in the left sidebar and click "Create Key". Give your key a name and click "Create".
  </Step>

  <Step title="Save immediately">
    Copy the key immediately - it's only shown once. Store it in a password manager.
  </Step>

  <Step title="Configure in Cellm">
    In Excel, open Cellm's ribbon menu, select the `anthropic` provider, click the provider icon, and paste your API key. Try a model like:

    ```mdx Claude example theme={null}
    =PROMPTMODEL("anthropic/claude-sonnet-4-6", "Analyze customer feedback", A1)
    ```
  </Step>
</Steps>

### DeepSeek

DeepSeek provides cost-effective AI models with OpenAI-compatible API.

<Steps>
  <Step title="Create an account">
    Go to [platform.deepseek.com](https://platform.deepseek.com) and sign up.
  </Step>

  <Step title="Generate API key">
    Navigate to the "API Keys" section and click "Create new API key". Optionally assign a name to your key.
  </Step>

  <Step title="Save your key">
    Copy the key immediately and store it securely - it won't be displayed again.
  </Step>

  <Step title="Configure in Cellm">
    In Excel, open Cellm's ribbon menu, select the `deepseek` provider (or `openaicompatible` with base address `https://api.deepseek.com`), click the provider icon, and paste your API key. Try a model like:

    ```mdx DeepSeek example theme={null}
    =PROMPTMODEL("deepseek/deepseek-chat", "Summarize text", A1)
    ```
  </Step>
</Steps>

### Other OpenAI-compatible providers

You can use any provider compatible with OpenAI's API format, including OpenRouter or LiteLLM.

<Info>
  Local models running on localhost are free to use. However, a Cellm subscription is required to access online APIs like openrouter.com or cerebras.ai. See [Cellm's subscription plans](https://getcellm.com/pricing) for details.
</Info>

<Steps>
  <Step title="Choose OpenAI Compatible provider">
    In Cellm's ribbon menu, select the `OpenAI Compatible` provider.
  </Step>

  <Step title="Configure endpoint">
    Click the provider icon to open settings. Enter the API endpoint URL and your API key.
  </Step>

  <Step title="Test the connection">
    Enter a model name and try a test prompt to verify the configuration works.
  </Step>
</Steps>

## Best practices

* **Store API keys securely**: Use a password manager or environment variables
* **Monitor usage**: Check your provider dashboard regularly to track costs
* **Start small**: Begin with smaller, cheaper models and scale up as needed
* **Test thoroughly**: Verify API setup with a few test prompts before processing large datasets


# Local Models
Source: https://docs.getcellm.com/models/local-models

How to use local models

Cellm supports local models that run on your computer via Llamafiles, Ollama, or vLLM. This ensures none of your data ever leaves your machine. And it's free.

On this page you will learn what to consider when choosing a local model and how to run it.

## Model sizes

We can split local models into three tiers based on their size and capabilities, balancing speed, intelligence, and world knowledge:

|                   | Small Model                                                  | Medium Model                                                 | Large Model                                                  |
| ----------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| Speed             | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| Intelligence      | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| World Knowledge   | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> | <Icon icon="star" /><Icon icon="star" /><Icon icon="star" /> |
| Recommended model | Gemma 4 E4B                                                  | Gemma 4 26B                                                  | Gemma 4 31B                                                  |

<Tip>
  You need a GPU for any of the medium or large models to be useful in practice. If you don't have a GPU, you can use [Hosted Models](/models/hosted-models) if small ones are insufficient.
</Tip>

In general, smaller models are faster and less intelligent, while larger models are slower and more intelligent. When using local models, it's important to find the right balance for your task, because speed impacts your productivity and intelligence impacts your results. You should try out different models and choose the smallest one that gives you good results.

Small models are sufficient for many common tasks such as categorizing text or extracting person names from news articles. Medium models are appropriate for more complex tasks such as document review, survey analysis, or tasks involving function calling. Large models are useful for creative writing, tasks requiring nuanced language understanding such as spam detection, or tasks requiring world knowledge.

Models larger than 32B require significant hardware investment to run locally, and you are better off using [Hosted Models](/models/hosted-models) if you need this kind of intelligence and don't have the hardware already.

<Tip>
  Large models are needed to use the Internet Browser tool effectively.
</Tip>

## Run models locally

You need to run a program on your computer that serves models to Cellm. We call these programs "providers". Cellm supports Ollama, Llamafiles, and vLLM, as well as any OpenAI-compatible provider. If you don't know any of these names, just use Ollama.

### Ollama

To get started with Ollama, we recommend you try out the Gemma 4 E4B model, which is Cellm's default local model.

<Steps>
  <Step title="Install Ollama">
    Download and install [Ollama](https://ollama.com/). Ollama will start after the install and automatically run whenever you start up your computer.
  </Step>

  <Step title="Download the model">
    When you select an Ollama model in Cellm, it will prompt you to download it automatically. Alternatively, open Windows Terminal (open start menu, type `Windows Terminal`, and click `OK`), then run:

    ```bash Download Gemma 4 E4B theme={null}
    ollama pull gemma4:e4b
    ```

    Wait for the download to finish.
  </Step>

  <Step title="Test in Excel">
    In Excel, select `ollama/gemma4:e4b` from the model dropdown menu, and type:

    ```mdx Test prompt theme={null}
    =PROMPT("Which model are you and who made you?")
    ```

    The model will tell you that it is called "Gemma 4" and made by Google DeepMind.
  </Step>
</Steps>

<Info>
  You can use any model that Ollama supports. See [https://ollama.com/search](https://ollama.com/search) for a complete list.
</Info>

### LLamafile

Llamafile is a project by Mozilla that combines llama.cpp with Cosmopolitan Libc, enabling you to download and run a single-file executable (called a "llamafile") that runs locally on most computers, with no installation.

<Steps>
  <Step title="Download a llamafile">
    Download a llamafile from [https://github.com/Mozilla-Ocho/llamafile](https://github.com/Mozilla-Ocho/llamafile) (e.g. [Gemma 3 4B IT](https://huggingface.co/Mozilla/gemma-3-4b-it-llamafile/resolve/main/google_gemma-3-4b-it-Q6_K.llamafile)).
  </Step>

  <Step title="Rename the file">
    Append `.exe` to the filename. For example, `google_gemma-3-4b-it-Q6_K.llamafile` should be renamed to `google_gemma-3-4b-it-Q6_K.llamafile.exe`.
  </Step>

  <Step title="Run the llamafile">
    Open Windows Terminal (open start menu, type `Windows Terminal`, and click `OK`) and run:

    ```bash CPU only theme={null}
    .\google_gemma-3-4b-it-Q6_K.llamafile.exe --server --v2
    ```

    To offload inference to your NVIDIA or AMD GPU, run:

    ```bash With GPU theme={null}
    .\google_gemma-3-4b-it-Q6_K.llamafile.exe --server --v2 -ngl 999
    ```
  </Step>

  <Step title="Configure Cellm">
    Start Excel and select the `OpenAiCompatible` provider from the model drop-down on Cellm's ribbon menu. Enter any model name e.g., "gemma". Llamafiles ignore the model name since each llamafile serves only one model, but a name is required by the OpenAI API.

    Set the Base Address to `http://localhost:8080`.
  </Step>
</Steps>

<Tip>
  Llamafiles are especially useful if you don't have the necessary permissions to install programs on your computer.
</Tip>

### Dockerized Ollama

If you prefer to run models via docker, both Ollama and vLLM are packaged up with docker compose files in the `docker/` folder. vLLM is designed to run many requests in parallel and particularly useful if you need to process a lot of data with Cellm.

<Steps>
  <Step title="Clone the repository">
    ```bash Clone repo theme={null}
    git clone https://github.com/getcellm/cellm
    ```
  </Step>

  <Step title="Start Ollama container">
    Run the following command in the `docker/` directory:

    ```bash Start container theme={null}
    docker compose -f docker-compose.Ollama.yml up --detach
    ```

    To use your GPU for faster inference:

    ```bash Start with GPU theme={null}
    docker compose -f docker-compose.Ollama.yml -f docker-compose.Ollama.GPU.yml up --detach
    ```

    To stop the container:

    ```bash Stop container theme={null}
    docker compose -f docker-compose.Ollama.yml down
    ```
  </Step>

  <Step title="Configure Cellm">
    Start Excel and select the `openaicompatible` provider from the model drop-down on Cellm's ribbon menu. Enter the model name you want to use, e.g., `gemma4:e4b`.

    Set the Base Address to `http://localhost:11434`.
  </Step>
</Steps>

To use other Ollama models, pull another of the [supported models](https://ollama.com/search) by running e.g. `ollama run mistral-small3.1:24b` in the container.

### Dockerized vLLM

If you want to speed up running many requests in parallel, you can use vLLM instead of Ollama. vLLM requires a Hugging Face API key to download models from the Hugging Face Hub.

<Steps>
  <Step title="Set up Hugging Face API key">
    You must supply the docker compose file with a Hugging Face API key either via an environment variable or by editing the docker compose file directly. Look at the vLLM docker compose file for details.

    If you don't know what a Hugging Face API key is, just use Ollama instead.
  </Step>

  <Step title="Start vLLM container">
    ```bash Start vLLM theme={null}
    docker compose -f docker-compose.vLLM.GPU.yml up --detach
    ```

    To use other vLLM models, change the `--model` argument in the docker compose file to another Hugging Face model.
  </Step>
</Steps>

<Tip>
  Open WebUI is included in both Ollama and vLLM docker compose files so you can test the local model outside of Cellm. Open WebUI is available at `http://localhost:3000`.
</Tip>


# Calling Functions
Source: https://docs.getcellm.com/usage/calling-functions

Enable Cellm models to call functions and access external data

Function Calling allows Cellm to interact with external tools and data, like searching files on your disk and reading their contents. When enabled, the model can dynamically call functions to retrieve relevant data before responding. Combined with Excels other formulas, function calling makes Cellm a powerful low-code automation tool.

## Enabling function calling

To allow models to call external functions, open the **Cellm** ribbon in Excel and check the functions you want to enable:

* **Internet Browser**: Let the model access web pages.
* **File Search**: Let the model search for files om your computer.
* **File Reader**: Let the model read text files on your computer, such as code or PDFs.

<Frame>
  <img />
</Frame>

## Calling a function

When function calling is enabled, you can write prompts that leverage these functions. You can explicitly ask the model to use a specific function in or prompt or leave to the model to decide when to use it.

### Example 1: Searching for Files

```excel theme={null}
=PROMPT.TOCOLUMN("Which PDF files do I have in the folder C:\Users\username\Invoices?")
```

With **File Search** enabled the model will first ask Cellm to run a function that finds all PDF files in your download folder. Cellm performs the search and sends the result back to the model, and the model uses this list to generate its actual response.

### Example 2: Classifying PDF files

```excel theme={null}
=PROMPT(A1, "If the PDF is a recurring invoice, respond with 'SUBSCRIPTION', otherwise respond with "ONE-TIME PAYMENT")
```

If **File Reader** is enabled, the model will ask Cellm to run a function that extracts text from the PDF. Cellm reads the file and sends the result back to the model, and the model uses the text to respond with the class.

You can drag the prompt down across all rows to classify all files.

## Dos and Don'ts

### Do:

* **Be specific:** Clearly tell the model which function to use and what to do. Instead of a vague prompt like "Analyze my invoices," guide it with `"Summarize the PDF file at C:\Invoices\inv-123.pdf"`.
* **Use cell references for dynamic workflows:** Put file paths or search queries in separate cells and reference them in your prompt (e.g., `=PROMPT(A1, "Summarize this file")`). This lets you drag formulas down to process hundreds of files at once.
* **Enable functions only when needed:** For security and performance, only activate the functions required for your current task. Disable them when you're finished.

### Don't:

* **Don't grant access to sensitive data with cloud models:** Avoid using functions like **File Reader** or **File Search** on confidential documents if you are using a cloud-based AI model (like from OpenAI or Google). Use local models for privacy-sensitive tasks.
* **Don't write vague prompts:** Avoid ambiguous requests like `"find the report"` if you have multiple reports. The more precise your prompt, the more reliable the result.


# Using MCP
Source: https://docs.getcellm.com/usage/using-mcp

How to connect AI models to external data and tools

MCP (Model Context Protocol) lets you plug in tools that extend what AI models can do. Want to search the web? There's an MCP server for that. Need to access your Salesforce data? There's one for that too. File system access, Slack integration, calendar management—people build MCP servers for all kinds of tasks.

With MCP, you can ask the AI to perform tasks that require external resources, such as:

* Search the web for current information
* Access data from Salesforce, HubSpot, or other CRM systems
* Read files from your local disk
* Send messages through Slack or check your calendar
* Query databases
* Interact with web pages through browser automation

<Info>
  Standard I/O MCP servers require Node.js or uv installed on your computer to run. The built-in Internet Browser tool requires Playwright dependencies. HTTP-based servers don't need local installations. See [installation instructions](/get-started/install#enable-mcp-optional).
</Info>

## Built-in MCP servers

Cellm comes with a built-in browser automation server called Playwright. This server lets AI models interact with websites—clicking buttons, filling forms, and extracting data. You can enable it in Cellm's ribbon menu under Tools → Enable Internet Browser.

<Info>
  To use the Internet Browser tool, you need to install Playwright's browser dependencies first. See the [installation instructions](/get-started/install#enable-mcp-optional).
</Info>

## Installation Requirements

To use MCP servers and tools, you may need to install:

* **Node.js** - Runtime to run Node.js-based MCP servers (most MCP servers like Salesforce, Slack, file system, etc.)
* **uv** - Runtime to run Python-based MCP servers
* **Playwright dependencies** - Browser binaries needed for the built-in Internet Browser tool

HTTP-based MCP servers run on remote servers and don't require any local installations.

For detailed installation instructions, see the [Enable MCP section](/get-started/install#enable-mcp-optional) on the install page.

## Adding MCP servers

You can add your own MCP servers to extend what AI models can do. MCP servers come in two types:

### Standard I/O servers

These are programs that run on your computer and communicate through standard input/output. Most MCP servers use this type.

<Info>
  Requires Node.js or uv installed on your computer to run the MCP server. [See installation requirements](#installation-requirements).
</Info>

<Steps>
  <Step title="Open MCP configuration">
    In Excel, go to Cellm's ribbon menu and click Tools → MCP Servers.
  </Step>

  <Step title="Add a new server">
    Click "Add Server" and select "Standard I/O" as the transport type.
  </Step>

  <Step title="Configure the server">
    * **Name**: Give your server a descriptive name (e.g., "File System")
    * **Command**: The program to run (e.g., `node`, `python`, or path to executable)
    * **Arguments**: Command-line arguments to pass to the program
    * **Working Directory**: (Optional) The directory to run the command from
    * **Environment Variables**: (Optional) Environment variables the server needs
  </Step>

  <Step title="Save and enable">
    Click "Save" and enable the server in the MCP Servers list.
  </Step>
</Steps>

### HTTP servers

These are web services that communicate over HTTP. They're useful for connecting to cloud-based MCP servers or servers running on other machines.

<Steps>
  <Step title="Open MCP configuration">
    In Excel, go to Cellm's ribbon menu and click Tools → MCP Servers.
  </Step>

  <Step title="Add a new server">
    Click "Add Server" and select "Streamable HTTP" as the transport type.
  </Step>

  <Step title="Configure the server">
    * **Name**: Give your server a descriptive name (e.g., "Weather API")
    * **Endpoint**: The HTTP endpoint URL (e.g., `https://api.example.com/mcp`)
    * **Transport Mode**: Usually "ServerSentEvents"
    * **Connection Timeout**: How long to wait for connection (in seconds)
    * **Additional Headers**: (Optional) HTTP headers for authentication
  </Step>

  <Step title="Save and enable">
    Click "Save" and enable the server in the MCP Servers list.
  </Step>
</Steps>

## Using MCP servers in prompts

Once you've enabled an MCP server, you can simply ask the AI to use it in your prompts. The AI will automatically detect when it needs to use an external tool.

<RequestExample>
  ```excel Search the web theme={null}
  =PROMPT("Search the web for recent news articles about renewable energy")
  ```

  ```excel Access CRM data theme={null}
  =PROMPT("Get all deals from Salesforce that closed this month")
  ```

  ```excel Check calendar theme={null}
  =PROMPT("Check my calendar for available meeting times tomorrow afternoon")
  ```

  ```excel Extract web data theme={null}
  =PROMPT("Go to https://example.com and extract all product names and prices")
  ```
</RequestExample>

<ResponseExample>
  ```excel With cell reference theme={null}
  =PROMPT("Search the web for information about this company", A1)
  ```

  Where A1 contains: `Microsoft`
</ResponseExample>

<Info>
  MCP servers are automatically used by the AI model when needed. You don't need to specify which server to use—the AI will choose the appropriate one based on your prompt.
</Info>

## Finding MCP servers

The MCP ecosystem is growing rapidly. Popular MCP servers include:

* **Salesforce MCP** - Access CRM data, leads, opportunities, and accounts
* **Slack MCP** - Send messages, search conversations, manage channels
* **Google Drive MCP** - Read and write documents, sheets, and files
* **GitHub MCP** - Search repositories, read code, manage issues
* **PostgreSQL/MySQL MCP** - Query databases directly
* **Browser automation** (built into Cellm) - Interact with any website

You can find more MCP servers at [mcp.so](https://mcp.so). For more information about MCP, visit [modelcontextprotocol.io](https://modelcontextprotocol.io).

<Tip>
  Many MCP servers are Node.js programs. If you see instructions that mention `npx` or `node`, you'll need Node.js installed on your computer. See the [installation instructions](/get-started/install#enable-mcp-optional) for setup details.
</Tip>

## Managing MCP servers

To edit or remove an MCP server:

1. Go to Cellm's ribbon menu → Tools → MCP Servers
2. Select the server from the list
3. Click "Edit" to change settings or "Remove" to delete it
4. Changes take effect immediately

## Best practices

**Test with simple prompts first**

* After adding an MCP server, test it with a simple prompt to verify it works
* Check that the AI can successfully use the server's tools

**Name servers descriptively**

* Use clear names that describe what the server does
* This helps you remember which servers you have enabled

**Disable unused servers**

* Keep only the servers you need enabled
* This improves performance and reduces potential conflicts

**Secure your credentials**

* If an MCP server needs API keys or passwords, use environment variables
* Don't put sensitive information directly in the configuration

**Monitor resource usage**

* MCP servers run as background processes
* If you notice performance issues, check which servers are running


# Writing Prompts
Source: https://docs.getcellm.com/usage/writing-prompts

Use LLMs in Excel formulas

This guide walks you through using Cellm's `=PROMPT()` function, from writing your first simple prompt to processing thousands of rows of data. We'll start with the basics and build up to more advanced features like batch processing and custom output formats.

## Write your first prompt in Excel

Cellm's `=PROMPT()` function outputs the AI response to a range of text, similar to how Excel's `=SUM()` function that outputs the sum of a range of numbers.

To get started, select a cell and write the formula `=PROMPT("Rate sentiment as positive, neutral, or negative: I love cupcakes!")`. The model will analyze the sentiment and return "positive" in the cell you selected:

<Frame>
  <img />
</Frame>

## Use data from your spreadsheet

Now that you know how to write a basic prompt, let's use data that's already in your spreadsheet. You can reference other cells in your `=PROMPT()` formula which lets you dynamically use other cells as context. To reference a single cell:

```mdx Single cell reference theme={null}
=PROMPT("Rate the sentiment as positive, neutral, or negative", A1)
```

This formula applies your prompt to the text in cell A1. The model uses the cell's content as context when following your instructions. Updates work just like any other Excel formula. When you change the data in column A, the results in column B update automatically.

You can also reference multiple cells at once (a cell "range"):

```mdx Cell range reference theme={null}
=PROMPT("Summarize the data", A1:A2)
```

This formula makes the model look at both A1 and A2. You can reference any range of cells using standard Excel notation like `A1:C5` or `A:A` for an entire column.

## Structure model output

When your prompt results in a list of answers (like "Extract all person names from the text"), Cellm can output each answer in its own cell. The `=PROMPT.TOROW()`, `=PROMPT.TOCOLUMN()`, and `=PROMPT.TORANGE()` functions output model responses as rows, columns, or in a rectangular grid. The **Output Shape** selectors in the Cellm ribbon let's you quickly add one of these formulas to a selected cell or change an existing formula's output format.

### Format as rows or columns

Use the `=PROMPT.TOROW()` or `=PROMPT.TOCOLUMN()` formulas to have Excel "spill" multiple values into other cells. For example, with the prompt:

```mdx Extract to row theme={null}
=PROMPT.TOROW("Extract all the features mentioned in this product review", A2)
```

* **=PROMPT.TOROW()**: Excel spills each feature into a new cell to the right (a row).
* **=PROMPT.TOCOLUMN()**: Excel spills each feature into new cells below (a column).

<Frame>
  <img />
</Frame>

### Format as a range

Use the `=PROMPT.TORANGE()` function when your output may span multiple rows and columns. You have two main ways to control the output:

1. **Let the model decide:** You provide a general prompt and allow the model to determine the best row and column structure for its response.
2. **Specify the format:** You include explicit instructions in your prompt to control the exact layout of the output, such as whether it should be a single row, a single column, or a table with a specific arrangement.

#### Example: Letting the model decide the format

To generate a table of synthetic data, you can use a prompt that describes the desired content and the number of rows. The model will then format the output in a rectangular grid.

For example:

```mdx Generate table theme={null}
=PROMPT.TORANGE("Give me 10 examples of synthetic data with email, name, and address.")
```

<Frame>
  <img />
</Frame>

#### Example: Specifying the output format

You can be more specific in your prompt to ensure the data is returned in the exact format you need. For example, instruct the model to place the values in a row:

```mdx Output as row theme={null}
=PROMPT.TORANGE("List the top 5 largest countries by area as a single row.")
```

or a column:

```mdx Output as column theme={null}
=PROMPT.TORANGE("List the first 5 months of the year in a single column.")
```

## Process many rows at once

Once you're comfortable with cell references and output formats, you can scale up to process large amounts of data. You can apply the same prompt to many rows of data by dragging formulas across rows or columns.

For example, you can import a CSV with a thousand news articles and put them in column A. In B1, write a formula like:

```mdx Batch processing theme={null}
=PROMPT.TOROW("Extract all person names mentioned in the text", A1)
```

Then drag the formula down to apply it to all your rows. Cellm will process each row and put the results in the corresponding cells in column B. This approach lets you automate tasks that would otherwise require copying and pasting data into a chat window over and over:

<img />

`#GETTING_DATA` means the prompt is queued up or has already been has been sent to the model and the cell is awaiting response.

## Use specific models with PROMPTMODEL

For advanced workflows, you might want to use different AI models for different types of analysis. You can use a specific model in any cell with the `=PROMPTMODEL()` function. This function takes a provider and model as its first argument but is otherwise identical to `=PROMPT()`.

The first argument consists of a provider and a model name separated by a forward slash (`/`). For example, if you want to use OpenAI's cheapest model in a particular cell, you can write:

```mdx Specify model theme={null}
=PROMPTMODEL("openai/gpt-5.4-mini", "Rate sentiment as positive, neutral, or negative", A1)
```

This is useful when you want to use a strong model by default but offload simple tasks to cheaper models.

<Tip>See [Choosing Model](/models/choosing-model) to learn more about choosing the right model for the right task.</Tip>

## Best practices

Now that you know how Cellm works, here are some guidelines for effective prompting:

**Do:**

* Experiment with different prompts to find the most effective instructions for your data.
* Use cell references to dynamically change your prompts based on other data in your spreadsheet.
* Use the output shape to format the structure of the model's response and the prompt to define the content.
* Use local models for sensitive and confidential data.
* When processing many rows, verify at least a subset of a model's responses. Models sometimes make errors and rely entirely on your input, which may also contain errors.

**Don't:**

* Don't use Cellm to compute sums, averages, and other numerical calculations. Combine Cellm with Excel's other functions instead.
* Don't use cloud providers to process sensitive or confidential data.
* Don't use extremely long prompts or give Cellm complex tasks. A normal chat UI lets you have a back and forth conversation which is better for exploring complex topics.
* Don't use Cellm for tasks that require up-to-date information beyond the AI model's knowledge cutoff date *unless* you provide the information as context.

## Next steps

You now have all the tools to use AI effectively in Excel. From here, you can explore more advanced features like function calling or learn how to choose the right model for your specific tasks.

<CardGroup>
  <Card title="Breaking Down Tasks" icon="server" href="/usage/breaking-down-tasks">
    Learn how to decompose your tasks into clear, manageable steps to improve AI reliability.
  </Card>

  <Card title="Choosing Model" icon="server" href="/models/local-models">
    Learn how to choose the right model for the right task.
  </Card>
</CardGroup>