Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.together.ai/llms.txt

Use this file to discover all available pages before exploring further.

Using a coding agent? Install the together-sandboxes skill to let your agent write correct sandbox code automatically. Learn more.
Together Code Interpreter (TCI) enables you to execute Python code in a sandboxed environment. The Code Interpreter currently only supports Python. We plan to expand the language options in the future.
ℹ️ MCP Server TCI is also available as an MCP server through Smithery. This makes it easier to add code interpreting abilities to any MCP client like Cursor, Windsurf, or your own chat app.

​
Run your first query using the TCI

from together import Together

client = Together()

## Run a simple print statement in the code interpreter
response = client.code_interpreter.run(
    code='print("Welcome to Together Code Interpreter!")',
    language="python",
)


print(f"Status: {response.data.status}")


for output in response.data.outputs:
    print(f"{output.type}: {output.data}")
Output
Text
Status: completed
stdout: Welcome to Together Code Interpreter!
ℹ️ Pricing information TCI usage is billed at $0.03/session. As detailed below, sessions have a lifespan of 60 minutes and can be used multiple times.

​
Example Use Cases

Overview of how Together Code Interpreter can be used in a code generation, execution and improvement iteration.
  • Reinforcement learning (RL) training: TCI transforms code execution into an interactive RL environment where generated code is run and evaluated in real time, providing reward signals from successes or failures, integrating automated pass/fail tests, and scaling easily across parallel workers—thus creating a powerful feedback loop that refines coding models over many trials.
  • Developing agentic workflows: TCI allows AI agents to seamlessly write and execute Python code, enabling robust, iterative, and secure computations within a closed-loop system.

​
Response Format

The API returns:
  • session_id: Identifier for the current session
  • outputs: Array of execution outputs, which can include:
    • Execution output (the return value of your snippet)
    • Standard output (stdout)
    • Standard error (stderr)
    • Error messages
    • Rich display data (images, HTML, etc.) Example
JSON
{
  "data": {
    "outputs": [
      {
        "data": "Hello, world!\n",
        "type": "stdout"
      },
      {
        "data": {
          "image/png": "iVBORw0KGgoAAAANSUhEUgAAA...",
          "text/plain": "<Figure size 640x480 with 1 Axes>"
        },
        "type": "display_data"
      }
    ],
    "session_id": "ses_CM42NfvvzCab123"
  },
  "errors": null
}

​
Usage overview

Together AI has created sessions to measure TCI usage. A session is an active code execution environment that can be called to execute code, they can be used multiple times and have a lifespan of 60 minutes. Typical TCI usage follows this workflow:
  1. Start a session (create a TCI instance).
  2. Call that session to execute code; TCI outputs stdout and stderr.
  3. Optionally reuse an existing session by calling its session_id.

​
Reusing sessions and maintaining state between runs

The session_id can be used to access a previously initialized session. All packages, variables, and memory will be retained. 
from together import Together

client = Together()

## set a variable x to 42
response1 = client.code_interpreter.run(code="x = 42", language="python")

session_id = response1.data.session_id

## print the value of x
response2 = client.code_interpreter.run(
    code='print(f"The value of x is {x}")',
    language="python",
    session_id=session_id,
)

for output in response2.data.outputs:
    print(f"{output.type}: {output.data}")
Output
Text
stdout: The value of x is 42

​
Using the TCI for Data analysis

Together Code Interpreter is a very powerful tool and gives you access to a fully functional coding environment. You can install Python libraries and conduct fully fledged data analysis experiments. 
from together import Together

client = Together()

## Create a code interpreter instance
code_interpreter = client.code_interpreter

code = """
!pip install numpy
import numpy as np

## Create a random matrix
matrix = np.random.rand(3, 3)
print("Random matrix:")
print(matrix)

## Calculate eigenvalues
eigenvalues = np.linalg.eigvals(matrix)
print("\\nEigenvalues:")
print(eigenvalues)
"""

response = code_interpreter.run(code=code, language="python")

for output in response.data.outputs:
    print(f"{output.type}: {output.data}")
if response.data.errors:
    print(f"Errors: {response.data.errors}")

​
Uploading and using files with TCI

from together import Together

client = Together()

## Create a code interpreter instance
code_interpreter = client.code_interpreter

script_content = "import sys\nprint(f'Hello from inside {sys.argv[0]}!')"

## Define the script file as a dictionary
script_file = {
    "name": "myscript.py",
    "encoding": "string",
    "content": script_content,
}

code_to_run_script = "!python myscript.py"

response = code_interpreter.run(
    code=code_to_run_script,
    language="python",
    files=[script_file],  # Pass the script dictionary in a list
)

## Print results
print(f"Status: {response.data.status}")
for output in response.data.outputs:
    print(f"{output.type}: {output.data}")
if response.data.errors:
    print(f"Errors: {response.data.errors}")
Output
Text
Status: completed
stdout: Hello from inside myscript.py!

​
Pre-installed dependencies

TCI’s Python sessions come pre-installed with the following dependencies, any other dependencies can be installed using a !pip install command in the python code.
Text
- aiohttp
- beautifulsoup4
- bokeh
- gensim
- imageio
- joblib
- librosa
- matplotlib
- nltk
- numpy
- opencv-python
- openpyxl
- pandas
- plotly
- pytest
- python-docx
- pytz
- requests
- scikit-image
- scikit-learn
- scipy
- seaborn
- soundfile
- spacy
- textblob
- tornado
- urllib3
- xarray
- xlrd
- sympy

​
List Active Sessions

To retrieve all your active sessions: 
from together import Together

client = Together()

response = client.code_interpreter.sessions.list()

for session in response.data.sessions:
    print(session.id)
Output:
JSON
{
  "data": {
    "sessions": [
      {
        "id": "ses_CVtmHZWnVBdtZnwbZNosk",
        "execute_count": 1,
        "expires_at": "2025-12-08T07:11:51.890310+00:00",
        "last_execute_at": "2025-12-08T06:41:52.188626+00:00",
        "started_at": "2025-12-08T06:41:51.890310+00:00"
      },
      {
        "id": "ses_CVtmJv6pRn1gHtiyQzEpS",
        "execute_count": 2,
        "expires_at": "2025-12-08T07:12:10.271865+00:00",
        "last_execute_at": "2025-12-08T06:42:11.334315+00:00",
        "started_at": "2025-12-08T06:42:10.271865+00:00"
      },
      {
        "id": "ses_CVtmLBDRcoVeNTzWBTQ6E",
        "execute_count": 1,
        "expires_at": "2025-12-08T07:12:27.372041+00:00",
        "last_execute_at": "2025-12-08T06:42:31.163214+00:00",
        "started_at": "2025-12-08T06:42:27.372041+00:00"
      }
    ]
  },
  "errors": null
}

​
Further reading

TCI API Reference docs Together Code Interpreter Cookbook

​
Troubleshooting & questions

If you have questions about integrating TCI into your workflow or encounter any issues, please contact us.