From 83df1c3f2399d81ba54e9fd354352f667880c911 Mon Sep 17 00:00:00 2001 From: "tembo[bot]" <208362400+tembo-io[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 20:39:54 +0000 Subject: [PATCH 1/7] docs: Add Notte integration guide Co-authored-by: null <> --- docs.json | 1 + integrations/notte.mdx | 111 ++++++++++++++++++++++++++++++++++++++ integrations/overview.mdx | 1 + 3 files changed, 113 insertions(+) create mode 100644 integrations/notte.mdx diff --git a/docs.json b/docs.json index dff0b0e..75db29a 100644 --- a/docs.json +++ b/docs.json @@ -111,6 +111,7 @@ ] }, "integrations/magnitude", + "integrations/notte", "integrations/stagehand", "integrations/valtown", "integrations/vercel" diff --git a/integrations/notte.mdx b/integrations/notte.mdx new file mode 100644 index 0000000..871163c --- /dev/null +++ b/integrations/notte.mdx @@ -0,0 +1,111 @@ +--- +title: "Notte" +--- + +[Notte](https://www.notte.cc/) is an AI agent framework that enables you to build sophisticated browser automation tasks. By integrating with Kernel, you can run Notte agents with cloud-hosted browsers using Chrome DevTools Protocol (CDP). + +## Adding Kernel to existing Notte implementations + +If you already have a Notte implementation, you can easily switch to using Kernel's cloud browsers by connecting via CDP. + +### 1. Install the required SDKs + +```bash +pip install notte-sdk kernel +``` + +### 2. Initialize Kernel and create a headless browser + +Import the libraries and create a headless cloud browser session: + +```python +from kernel import Kernel +from notte_sdk import NotteClient + +# Initialize Kernel client +client = Kernel(api_key="your-api-key") + +# Create a headless Kernel browser session +kernel_browser = client.browsers.create(headless=True) +``` + +### 3. Connect Notte to Kernel's CDP endpoint + +Use Kernel's CDP WebSocket URL to create a Notte session: + +```python +# Initialize Notte client +notte = NotteClient() + +# Connect to Kernel browser via CDP +with notte.Session(cdp_url=kernel_browser.cdp_ws_url) as session: + # Create and run your agent + agent = notte.Agent(session=session, max_steps=5) + agent.run(task="extract pricing plans from https://www.notte.cc/") +``` + +### 4. Clean up the browser session + +After your automation completes, tear down the Kernel browser: + +```python +# Clean up +client.browsers.delete_by_id(kernel_browser.session_id) +``` + +## Complete example script + +Here's a complete, runnable script that demonstrates the full integration: + +```python +from kernel import Kernel +from notte_sdk import NotteClient + +def main(): + # Initialize clients + client = Kernel(api_key="your-api-key") + notte = NotteClient() + + # Create a headless browser on Kernel + kernel_browser = client.browsers.create(headless=True) + + try: + # Connect Notte to Kernel's browser via CDP + with notte.Session(cdp_url=kernel_browser.cdp_ws_url) as session: + # Create an agent with a task + agent = notte.Agent(session=session, max_steps=10) + + # Run your automation task + result = agent.run( + task="Go to https://example.com and extract the main heading" + ) + + print(f"Task completed: {result}") + + except Exception as e: + print(f"Error during automation: {e}") + + finally: + # Always clean up the browser session + client.browsers.delete_by_id(kernel_browser.session_id) + print("Browser session cleaned up") + +if __name__ == "__main__": + main() +``` + +## Benefits of using Kernel with Notte + +- **No local browser management**: Run agents without installing or maintaining browsers locally +- **Headless execution**: Perfect for server environments and CI/CD pipelines +- **Scalability**: Launch multiple browser sessions in parallel for concurrent tasks +- **Cloud infrastructure**: Leverage Kernel's optimized browser infrastructure +- **Stealth mode**: Built-in anti-detection features for web scraping +- **Session control**: Programmatic control over browser lifecycle + +## Next steps + +- Learn about [creating browsers](/browsers/create-a-browser) on Kernel +- Check out [live view](/browsers/live-view) for debugging your automations +- Learn about [stealth mode](/browsers/stealth) for avoiding detection +- Explore [session persistence](/browsers/persistence) for maintaining browser state diff --git a/integrations/overview.mdx b/integrations/overview.mdx index 377ac99..1e46014 100644 --- a/integrations/overview.mdx +++ b/integrations/overview.mdx @@ -19,6 +19,7 @@ Kernel provides detailed guides for popular agent frameworks: - **[Browser Use](/integrations/browser-use)** - AI browser agent framework - **[Stagehand](/integrations/stagehand)** - AI browser automation with natural language +- **[Notte](/integrations/notte)** - AI agent framework for sophisticated browser automation - **[Computer Use (Anthropic)](/integrations/computer-use/anthropic)** - Claude's computer use capability - **[Computer Use (OpenAI)](/integrations/computer-use/openai)** - OpenAI's computer use capability - **[Magnitude](/integrations/magnitude)** - Vision-focused browser automation framework From e40de5068a4eac94f1d5fa87575eeaf4766d8f7b Mon Sep 17 00:00:00 2001 From: "tembo[bot]" <208362400+tembo-io[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 21:19:14 +0000 Subject: [PATCH 2/7] feat(notte): update integration docs with improved example --- integrations/notte.mdx | 93 ++++++++++++++++++++++++++++----------- integrations/overview.mdx | 2 +- 2 files changed, 68 insertions(+), 27 deletions(-) diff --git a/integrations/notte.mdx b/integrations/notte.mdx index 871163c..00316d4 100644 --- a/integrations/notte.mdx +++ b/integrations/notte.mdx @@ -11,22 +11,37 @@ If you already have a Notte implementation, you can easily switch to using Kerne ### 1. Install the required SDKs ```bash -pip install notte-sdk kernel +uv pip install notte-sdk kernel ``` -### 2. Initialize Kernel and create a headless browser +### 2. Initialize Kernel and create a browser -Import the libraries and create a headless cloud browser session: +Import the libraries and create a cloud browser session: ```python from kernel import Kernel from notte_sdk import NotteClient +import os +from dotenv import load_dotenv -# Initialize Kernel client -client = Kernel(api_key="your-api-key") +# Load environment variables from .env file +load_dotenv() -# Create a headless Kernel browser session -kernel_browser = client.browsers.create(headless=True) +# Initialize clients +kernel_api_key = os.getenv("KERNEL_API_KEY") +notte_api_key = os.getenv("NOTTE_API_KEY") + +if not kernel_api_key: + raise ValueError("KERNEL_API_KEY not found in environment variables") +if not notte_api_key: + raise ValueError("NOTTE_API_KEY not found in environment variables") + +kernel_client = Kernel(api_key=kernel_api_key) +notte_client = NotteClient(api_key=notte_api_key) + +# Create a headful browser on Kernel +print("Creating browser session on Kernel...") +kernel_browser = kernel_client.browsers.create(headless=False) ``` ### 3. Connect Notte to Kernel's CDP endpoint @@ -34,14 +49,22 @@ kernel_browser = client.browsers.create(headless=True) Use Kernel's CDP WebSocket URL to create a Notte session: ```python -# Initialize Notte client -notte = NotteClient() - -# Connect to Kernel browser via CDP -with notte.Session(cdp_url=kernel_browser.cdp_ws_url) as session: - # Create and run your agent - agent = notte.Agent(session=session, max_steps=5) - agent.run(task="extract pricing plans from https://www.notte.cc/") +try: + # Connect Notte to Kernel's browser via CDP + print("Connecting Notte to Kernel browser...") + with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session: + # Create an agent with a task + agent = notte_client.Agent(session=session, max_steps=10) + + # Run your automation task + result = agent.run( + task="extract pricing plans from https://www.notte.cc" + ) + + print(f"Task completed: {result.answer}") + +except Exception as e: + print(f"Error during automation: {e}") ``` ### 4. Clean up the browser session @@ -49,8 +72,10 @@ with notte.Session(cdp_url=kernel_browser.cdp_ws_url) as session: After your automation completes, tear down the Kernel browser: ```python -# Clean up -client.browsers.delete_by_id(kernel_browser.session_id) +finally: + # Always clean up the browser session + kernel_client.browsers.delete_by_id(kernel_browser.session_id) + print("Browser session cleaned up") ``` ## Complete example script @@ -60,34 +85,50 @@ Here's a complete, runnable script that demonstrates the full integration: ```python from kernel import Kernel from notte_sdk import NotteClient +import os +from dotenv import load_dotenv + +# Load environment variables from .env file +load_dotenv() def main(): # Initialize clients - client = Kernel(api_key="your-api-key") - notte = NotteClient() + kernel_api_key = os.getenv("KERNEL_API_KEY") + notte_api_key = os.getenv("NOTTE_API_KEY") + + if not kernel_api_key: + raise ValueError("KERNEL_API_KEY not found in environment variables") + if not notte_api_key: + raise ValueError("NOTTE_API_KEY not found in environment variables") + + kernel_client = Kernel(api_key=kernel_api_key) + notte_client = NotteClient(api_key=notte_api_key) - # Create a headless browser on Kernel - kernel_browser = client.browsers.create(headless=True) + # Create a headful browser on Kernel + print("Creating browser session on Kernel...") + kernel_browser = kernel_client.browsers.create(headless=False) + # print(kernel_browser.browser_live_view_url) try: # Connect Notte to Kernel's browser via CDP - with notte.Session(cdp_url=kernel_browser.cdp_ws_url) as session: + print("Connecting Notte to Kernel browser...") + with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session: # Create an agent with a task - agent = notte.Agent(session=session, max_steps=10) + agent = notte_client.Agent(session=session, max_steps=10) # Run your automation task result = agent.run( - task="Go to https://example.com and extract the main heading" + task="extract pricing plans from https://www.notte.cc" ) - print(f"Task completed: {result}") + print(f"Task completed: {result.answer}") except Exception as e: print(f"Error during automation: {e}") finally: # Always clean up the browser session - client.browsers.delete_by_id(kernel_browser.session_id) + kernel_client.browsers.delete_by_id(kernel_browser.session_id) print("Browser session cleaned up") if __name__ == "__main__": diff --git a/integrations/overview.mdx b/integrations/overview.mdx index 1e46014..1bf9ac4 100644 --- a/integrations/overview.mdx +++ b/integrations/overview.mdx @@ -19,10 +19,10 @@ Kernel provides detailed guides for popular agent frameworks: - **[Browser Use](/integrations/browser-use)** - AI browser agent framework - **[Stagehand](/integrations/stagehand)** - AI browser automation with natural language -- **[Notte](/integrations/notte)** - AI agent framework for sophisticated browser automation - **[Computer Use (Anthropic)](/integrations/computer-use/anthropic)** - Claude's computer use capability - **[Computer Use (OpenAI)](/integrations/computer-use/openai)** - OpenAI's computer use capability - **[Magnitude](/integrations/magnitude)** - Vision-focused browser automation framework +- **[Notte](/integrations/notte)** - AI agent framework for browser automation - **[Val Town](/integrations/valtown)** - Serverless function runtime - **[Vercel](https://github.com/onkernel/vercel-template)** - Deploy browser automations to Vercel From d6d4c93fb9ef46e69284ad38c43107cbcfc73cd2 Mon Sep 17 00:00:00 2001 From: "tembo[bot]" <208362400+tembo-io[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 21:27:39 +0000 Subject: [PATCH 3/7] refactor(notte): simplify integration guide with minimal code --- integrations/notte.mdx | 51 ++++++++++++------------------------------ 1 file changed, 14 insertions(+), 37 deletions(-) diff --git a/integrations/notte.mdx b/integrations/notte.mdx index 00316d4..a36fee1 100644 --- a/integrations/notte.mdx +++ b/integrations/notte.mdx @@ -21,26 +21,12 @@ Import the libraries and create a cloud browser session: ```python from kernel import Kernel from notte_sdk import NotteClient -import os -from dotenv import load_dotenv - -# Load environment variables from .env file -load_dotenv() # Initialize clients -kernel_api_key = os.getenv("KERNEL_API_KEY") -notte_api_key = os.getenv("NOTTE_API_KEY") - -if not kernel_api_key: - raise ValueError("KERNEL_API_KEY not found in environment variables") -if not notte_api_key: - raise ValueError("NOTTE_API_KEY not found in environment variables") - -kernel_client = Kernel(api_key=kernel_api_key) -notte_client = NotteClient(api_key=notte_api_key) +kernel_client = Kernel(api_key="your-kernel-api-key") +notte_client = NotteClient(api_key="your-notte-api-key") -# Create a headful browser on Kernel -print("Creating browser session on Kernel...") +# Create a browser on Kernel kernel_browser = kernel_client.browsers.create(headless=False) ``` @@ -49,22 +35,15 @@ kernel_browser = kernel_client.browsers.create(headless=False) Use Kernel's CDP WebSocket URL to create a Notte session: ```python -try: - # Connect Notte to Kernel's browser via CDP - print("Connecting Notte to Kernel browser...") - with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session: - # Create an agent with a task - agent = notte_client.Agent(session=session, max_steps=10) - - # Run your automation task - result = agent.run( - task="extract pricing plans from https://www.notte.cc" - ) - - print(f"Task completed: {result.answer}") - -except Exception as e: - print(f"Error during automation: {e}") +# Connect Notte to Kernel's browser via CDP +with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session: + # Create an agent with a task + agent = notte_client.Agent(session=session, max_steps=10) + + # Run your automation task + result = agent.run( + task="extract pricing plans from https://www.notte.cc" + ) ``` ### 4. Clean up the browser session @@ -72,10 +51,8 @@ except Exception as e: After your automation completes, tear down the Kernel browser: ```python -finally: - # Always clean up the browser session - kernel_client.browsers.delete_by_id(kernel_browser.session_id) - print("Browser session cleaned up") +# Clean up the browser session +kernel_client.browsers.delete_by_id(kernel_browser.session_id) ``` ## Complete example script From 35c61c96de4083cdce05f2946d9d16518b9decb5 Mon Sep 17 00:00:00 2001 From: "tembo[bot]" <208362400+tembo-io[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 21:33:14 +0000 Subject: [PATCH 4/7] docs(notte): remove headless browser benefits reference --- integrations/notte.mdx | 1 - 1 file changed, 1 deletion(-) diff --git a/integrations/notte.mdx b/integrations/notte.mdx index a36fee1..dedb199 100644 --- a/integrations/notte.mdx +++ b/integrations/notte.mdx @@ -115,7 +115,6 @@ if __name__ == "__main__": ## Benefits of using Kernel with Notte - **No local browser management**: Run agents without installing or maintaining browsers locally -- **Headless execution**: Perfect for server environments and CI/CD pipelines - **Scalability**: Launch multiple browser sessions in parallel for concurrent tasks - **Cloud infrastructure**: Leverage Kernel's optimized browser infrastructure - **Stealth mode**: Built-in anti-detection features for web scraping From 7a33a70140dbbb54511499d652cce122a13dee2b Mon Sep 17 00:00:00 2001 From: "tembo[bot]" <208362400+tembo-io[bot]@users.noreply.github.com> Date: Tue, 21 Oct 2025 21:35:31 +0000 Subject: [PATCH 5/7] docs: remove notte-sdk from installation requirements --- integrations/notte.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/integrations/notte.mdx b/integrations/notte.mdx index dedb199..6310d24 100644 --- a/integrations/notte.mdx +++ b/integrations/notte.mdx @@ -11,7 +11,7 @@ If you already have a Notte implementation, you can easily switch to using Kerne ### 1. Install the required SDKs ```bash -uv pip install notte-sdk kernel +uv pip install kernel ``` ### 2. Initialize Kernel and create a browser From 64035548b2ce759e23b2811282799d2480a4bdd3 Mon Sep 17 00:00:00 2001 From: Daniel Prevoznik Date: Tue, 21 Oct 2025 14:39:26 -0700 Subject: [PATCH 6/7] Update notte.mdx Small edits --- integrations/notte.mdx | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/integrations/notte.mdx b/integrations/notte.mdx index 6310d24..90dd4b1 100644 --- a/integrations/notte.mdx +++ b/integrations/notte.mdx @@ -8,7 +8,7 @@ title: "Notte" If you already have a Notte implementation, you can easily switch to using Kernel's cloud browsers by connecting via CDP. -### 1. Install the required SDKs +### 1. Install the Kernel SDK ```bash uv pip install kernel @@ -32,7 +32,7 @@ kernel_browser = kernel_client.browsers.create(headless=False) ### 3. Connect Notte to Kernel's CDP endpoint -Use Kernel's CDP WebSocket URL to create a Notte session: +Use Kernel's CDP URL to create a Notte session: ```python # Connect Notte to Kernel's browser via CDP @@ -48,10 +48,9 @@ with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session: ### 4. Clean up the browser session -After your automation completes, tear down the Kernel browser: +After your automation completes, clean up the Kernel browser: ```python -# Clean up the browser session kernel_client.browsers.delete_by_id(kernel_browser.session_id) ``` From 46d7514ac7d39eedd9250ea1d26272519ad1075c Mon Sep 17 00:00:00 2001 From: Daniel Prevoznik Date: Tue, 21 Oct 2025 15:13:56 -0700 Subject: [PATCH 7/7] Remove headless param Remove headless param and use headful default --- integrations/notte.mdx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/integrations/notte.mdx b/integrations/notte.mdx index 90dd4b1..d6ec867 100644 --- a/integrations/notte.mdx +++ b/integrations/notte.mdx @@ -27,7 +27,7 @@ kernel_client = Kernel(api_key="your-kernel-api-key") notte_client = NotteClient(api_key="your-notte-api-key") # Create a browser on Kernel -kernel_browser = kernel_client.browsers.create(headless=False) +kernel_browser = kernel_client.browsers.create() ``` ### 3. Connect Notte to Kernel's CDP endpoint @@ -82,7 +82,7 @@ def main(): # Create a headful browser on Kernel print("Creating browser session on Kernel...") - kernel_browser = kernel_client.browsers.create(headless=False) + kernel_browser = kernel_client.browsers.create() # print(kernel_browser.browser_live_view_url) try: