e2b scaling example, simple

Author: martinibach

community/e2b/README.md

@@ -1,65 +1,88 @@
-# Restack AI - Quickstart
+# E2B Code Execution with Restack AI
 
-This repository contains a quickstart for Restack.
-It demonstrates how to set up a basic workflow and functions.
+This repository demonstrates how to use [E2B](https://e2b.dev) for code execution at scale with [Restack](https://docs.restack.io/). E2B provides secure sandboxed environments for code execution, while Restack handles workflow orchestration and scaling.
 
 ## Prerequisites
 
 - Docker (for running Restack)
 - Python 3.10 or higher
+- E2B API key ([Get it here](https://e2b.dev/docs/getting-started/api-key))
+- OpenAI API key (for AI functionalities)
+
+## Configuration
+
+1. Copy `.env.Example` to `.env`
+2. Add your API keys:
+   ```
+   E2B_API_KEY=<your-e2b-api-key>
+   OPENAI_API_KEY=<your-openai-api-key>
+   ```
 
 ## Start Restack
 
-To start the Restack, use the following Docker command:
+To start Restack locally, use the following Docker command:
 
 ```bash
 docker run -d --pull always --name restack -p 5233:5233 -p 6233:6233 -p 7233:7233 ghcr.io/restackio/restack:main
 ```
 
-## Start python shell
+## Setup Python Environment
 
 ```bash
 poetry env use 3.10 && poetry shell
 ```
 
-## Install dependencies
+## Install Dependencies
 
 ```bash
 poetry install
 ```
 
+For IDE setup (optional):
 ```bash
-poetry env info # Optional: copy the interpreter path to use in your IDE (e.g. Cursor, VSCode, etc.)
+poetry env info # Copy the interpreter path to use in your IDE (e.g. Cursor, VSCode)
 ```
 
+Start the development server:
 ```bash
 poetry run dev
 ```
 
-## Run workflows
+## Running Workflows
 
-### from UI
+### Via UI
 
-You can run workflows from the UI by clicking the "Run" button.
+Access the Restack UI to run and monitor workflows:
 
-![Run workflows from UI](./screenshot-quickstart.png)
+![Restack Workflow UI](./ui-e2b-restack-code-execution.png)
 
-### from API
+### Via API
 
-You can run workflows from the API by using the generated endpoint:
+Execute workflows through the Restack API endpoint:
 
 `POST http://localhost:6233/api/workflows/GreetingWorkflow`
 
-### from any client
+### Via Client
 
-You can run workflows with any client connected to Restack, for example:
+Run workflows programmatically using the Python client:
 
 ```bash
 poetry run schedule
 ```
 
-executes `schedule_workflow.py` which will connect to Restack and execute the `GreetingWorkflow` workflow.
+This executes `schedule_workflow.py` which connects to Restack and runs the `GreetingWorkflow`.
+
+## Cloud Deployment
+
+### Restack Cloud
+Deploy your workflows on Restack Cloud:
+1. Create an account at [Restack Console](https://console.restack.io)
+2. Create a stack and import the cloned repository
+3. Reference the Dockerfile path `community/e2b/Dockerfile` and the build context `community/e2b`
+4. Set the environment variables for E2B and OpenAI. Restack environment variables are set automatically.
+
 
-## Deploy on Restack Cloud
+## Learn More
+- [Restack Documentation](https://docs.restack.io)
+- [E2B Documentation](https://e2b.dev/docs)
 
-To deploy the application on Restack, you can create an account at [https://console.restack.io](https://console.restack.io)

community/e2b/pyproject.toml

@@ -1,8 +1,8 @@
 # Project metadata
 [tool.poetry]
-name = "quickstart"
+name = "e2b-restack"
 version = "0.0.1"
-description = "A quickstart for Restack"
+description = "A simple example for e2b with Restack"
 authors = [
     "Restack Team <[email protected]>",
 ]

community/e2b/schedule_calendar.py

@@ -1,16 +1,16 @@
 import asyncio
 import time
 from restack_ai import Restack
-from src.workflows.workflow import GreetingWorkflowInput
-async def main():
+from src.workflows.many_code_executions import ManyCodeExecutionWorkflow, ManyCodeExecutionWorkflowInput
 
+async def main():
     client = Restack()
 
-    workflow_id = f"{int(time.time() * 1000)}-GreetingWorkflow"
+    workflow_id = f"{int(time.time() * 1000)}-ManyCodeExecutionWorkflow"
     run_id = await client.schedule_workflow(
-        workflow_name="GreetingWorkflow",
+        workflow_name="ManyCodeExecutionWorkflow",
         workflow_id=workflow_id,
-        input=GreetingWorkflowInput(name="Bob")
+        input=ManyCodeExecutionWorkflowInput()
     )
 
     await client.get_workflow_result(

community/e2b/schedule_interval.py

@@ -15,7 +15,8 @@ async def e2b_execute_python(input: ExecutePythonInput) -> str:
         # Create a new sandbox instance with a 60 second timeout
         sandbox = Sandbox(timeout=60)
         execution = sandbox.run_code(input.code)
-        return execution.logs
+        result = execution.text
+        return result
     except Exception as e:
         log.error("e2b_execute_python function failed", error=e)
         raise e

community/e2b/schedule_workflow.py

@@ -4,9 +4,9 @@
 from openai import OpenAI
 
 class OpenaiToolCallInput(BaseModel):
-    user_content: str
-    system_content: str = "You are an expert in Python. You can execute Python code and return the result."
-    tools: list[str]
+    user_content: str | None = None
+    system_content: str | None = None
+    tools: list[dict] = []
     model: str = "gpt-4"
     messages: list[dict] = []
 
@@ -20,12 +20,14 @@ async def openai_tool_call(input: OpenaiToolCallInput) -> dict:
         messages = input.messages.copy() if input.messages else [
             {"role": "system", "content": input.system_content}
         ]
-        messages.append({"role": "user", "content": input.user_content})
+        
+        if input.user_content:
+            messages.append({"role": "user", "content": input.user_content})
 
         response = client.chat.completions.create(
             model=input.model,
             messages=messages,
-            tools=input.tools,
+            **({"tools": input.tools} if input.tools else {})
         )
 
         response_message = response.choices[0].message

community/e2b/src/functions/e2b_execute_python.py

@@ -6,13 +6,13 @@
 from src.client import client
 from src.functions.e2b_execute_python import e2b_execute_python
 from src.functions.openai_tool_call import openai_tool_call
-from src.workflows.workflow import E2BWorkflow
-
+from src.workflows.code_execution import CodeExecutionWorkflow
+from src.workflows.many_code_executions import ManyCodeExecutionWorkflow
 
 async def main():
 
     await client.start_service(
-        workflows=[E2BWorkflow],
+        workflows=[CodeExecutionWorkflow, ManyCodeExecutionWorkflow],
         functions=[e2b_execute_python, openai_tool_call]
     )
 

community/e2b/src/functions/openai_tool_call.py

@@ -0,0 +1,58 @@
+from pydantic import BaseModel, Field
+from restack_ai.workflow import workflow, import_functions
+import json
+
+with import_functions():
+    from src.functions.e2b_execute_python import e2b_execute_python, ExecutePythonInput
+    from src.functions.openai_tool_call import openai_tool_call, OpenaiToolCallInput
+
+class CodeExecutionWorkflowInput(BaseModel):
+    user_content: str = Field(default='Calculate how many r\'s are in the word \'strawberry\'')
+    system_content: str = Field(default='You are an expert in Python. You can execute Python code and return the result.')
+
+class CodeExecutionWorkflowOutput(BaseModel):
+    content: str
+
+@workflow.defn()
+class CodeExecutionWorkflow:
+    @workflow.run
+    async def run(self, input: CodeExecutionWorkflowInput) -> CodeExecutionWorkflowOutput:
+
+        messages = []
+        while True:
+            llm_response = await workflow.step(openai_tool_call, input=OpenaiToolCallInput(
+                model="gpt-4o-mini",
+                user_content=input.user_content if not messages else None,
+                system_content=input.system_content if not messages else None,
+                messages=messages,
+                tools=[{
+                    "type": "function",
+                    "function": {
+                        "name": "execute_python",
+                        "description": "Execute python code in a Jupyter notebook cell and return result",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "code": {"type": "string", "description": "The python code to execute"}
+                            },
+                            "required": ["code"]
+                        }
+                    }
+                }] if not messages else []
+            ))
+
+            messages = llm_response["messages"]
+            
+            if not llm_response["response"].get("tool_calls"):
+                return CodeExecutionWorkflowOutput(content=llm_response["response"].get("content"))
+                
+            tool_call = llm_response["response"]["tool_calls"][0]
+            code = json.loads(tool_call["function"]["arguments"])["code"]
+            code_execution_output = await workflow.step(e2b_execute_python, input=ExecutePythonInput(code=code))
+
+            messages.append({
+                "role": "tool",
+                "name": "execute_python",
+                "content": str(code_execution_output),
+                "tool_call_id": tool_call["id"]
+            })

community/e2b/src/services.py

@@ -0,0 +1,39 @@
+from pydantic import BaseModel, Field
+from restack_ai.workflow import workflow
+from typing import List, Dict
+from src.workflows.code_execution import CodeExecutionWorkflow, CodeExecutionWorkflowInput
+import asyncio
+
+
+class ManyCodeExecutionWorkflowInput(BaseModel):
+    tasks: List[str] = Field(default=[
+        'Calculate how many r\'s are in the word \'strawberry\'',
+        'Find the sum of numbers from 1 to 100',
+        'Calculate the factorial of 5',
+        'Count the vowels in the word \'elephant\'',
+        'Generate a list of first 10 Fibonacci numbers',
+        'Check if 17 is a prime number',
+        'Convert 25 Celsius to Fahrenheit',
+        'Calculate the area of a circle with radius 5',
+        'Find all even numbers between 1 and 20',
+        'Calculate the length of the hypotenuse for a right triangle with sides 3 and 4'
+    ])
+
+class ManyCodeExecutionWorkflowOutput(BaseModel):
+    results: List[str] = Field(default=[])
+    
+    
+@workflow.defn()
+class ManyCodeExecutionWorkflow:
+    @workflow.run
+    async def run(self, input: ManyCodeExecutionWorkflowInput) -> ManyCodeExecutionWorkflowOutput:
+        tasks = [
+            workflow.child_execute(
+                CodeExecutionWorkflow,
+                workflow_id=f"code_execution_{i}",
+                input=CodeExecutionWorkflowInput(user_content=task)
+            )
+            for i, task in enumerate(input.tasks)
+        ]
+        results = await asyncio.gather(*tasks)
+        return ManyCodeExecutionWorkflowOutput(results=[r.content for r in results])