codeinterpreter-api

Translates natural language requests into executable Python code by routing prompts through configurable LLM providers (OpenAI, Azure OpenAI, Anthropic) via LangChain abstraction layer. The system maintains conversation memory across interactions, allowing the LLM to reference prior code execution results and refine generated code iteratively based on runtime feedback. Implementation uses LangChain's agent framework to chain LLM calls with code execution feedback loops.

Executes arbitrary Python code in an isolated CodeBox environment (local or remote API) with automatic dependency resolution and installation. The system intercepts import statements, detects missing packages, and installs them via pip before execution continues. Output (stdout, stderr, generated files) is captured and returned to the caller. Supports both synchronous and asynchronous execution patterns.

Allows executed code to access external internet resources (APIs, web scraping, downloading files) from within the sandboxed environment. Network access is configured at the CodeBox level and can be restricted or allowed based on deployment requirements. Code can make HTTP requests, download datasets, and interact with external services.

Manages input and output files within a session-scoped temporary storage system. Users upload files (CSV, images, documents, etc.) which are stored in a session directory, made available to executed code, and can be downloaded after processing. The File class provides a high-level abstraction for file operations. Session cleanup removes all temporary files when the session ends. Supports both synchronous and asynchronous file operations.

Maintains conversation history and execution context across multiple turns within a single CodeInterpreterSession. Each turn includes the user prompt, generated code, execution output, and any files produced. The LLM can reference prior execution results when generating new code, enabling iterative refinement and multi-step workflows. Context is stored in memory and passed to the LLM on each turn via LangChain's message history mechanism.

Abstracts code execution backend through a configurable CodeBox integration layer that supports both local Docker-based execution and remote CodeBox API endpoints. Developers can switch between local development (full control, no external dependencies) and production deployment (scalable, managed infrastructure) by changing configuration. The system handles authentication, request routing, and result marshaling transparently.

Enables data analysis workflows by automatically installing and providing access to popular Python libraries (pandas, numpy, matplotlib, seaborn, plotly, etc.) within the execution sandbox. The LLM can generate code that loads datasets, performs statistical analysis, creates visualizations, and exports results. The system handles library installation transparently when code imports these packages.

Provides both synchronous and asynchronous APIs for code execution, allowing integration into async Python frameworks (FastAPI, aiohttp, etc.). Async operations enable non-blocking execution, allowing a single application instance to handle multiple concurrent code execution requests without thread overhead. The async interface mirrors the synchronous API, making it easy to switch between them.

Allows developers to register custom Python functions as tools that the LLM can call during code generation. Tools are exposed to the LLM via a schema-based registry, enabling the agent to invoke custom logic (API calls, database queries, external services) as part of generated code execution. Tool definitions include name, description, and parameter schema for LLM understanding.

Provides pre-built frontend integrations for Streamlit and Chainlit, enabling rapid deployment of conversational code execution interfaces without building custom UI. These integrations handle session management, file upload/download, conversation display, and code execution triggering. Developers can deploy a fully functional web interface by writing minimal configuration code.

Captures code execution errors (syntax errors, runtime exceptions, import failures) and returns them to the LLM as part of the conversation context. The LLM can then analyze the error, understand what went wrong, and generate corrected code in the next turn. Error messages include stack traces and contextual information. This enables iterative debugging without user intervention.