semvec/pypi-packages huggingface dataset:
notte-mcp 1.8.5
The MCP server for Notte
Requires Python: >=3.11

<div align="center">
  <p>
    ⚡️ we outperform other web agents in speed, costs and reliability 👉🏼 <a href="https://github.com/nottelabs/open-operator-evals">read more on open-operator-evals</a>
  </p>
</div>

<p align="center">
  <img src="../../docs/logo/bgd.png" alt="Notte Logo" width="100%">
</p>

# Notte MCP Server

<div align="center">
  <h1>Notte MCP Server</h1>
  <p><em>MCP server for all Notte tools in the agentic ecosystem.</em></p>
  <p><strong>Manage your sessions. Run agents. Take control: observe, scrape, act, authenticate.</strong></p>
  <hr/>
</div>
[The Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) provides a standardized protocol for connecting LLM applications with external tools and data sources. It enables seamless integration between language models and the context they need, whether you're developing an AI-powered IDE, building a chat interface, or designing custom AI workflows.

## Available Tools

### Session Management

| Tool | Description |
|------|-------------|
| `notte_start_session` | Start a new cloud browser session |
| `notte_list_sessions` | List all active browser sessions |
| `notte_stop_session` | Stop the current session |

### Page Interaction & Scraping

| Tool | Description |
|------|-------------|
| `notte_observe` | Observe elements and available actions on the current page |
| `notte_screenshot` | Take a screenshot of the current page |
| `notte_scrape` | Extract structured data from the current page |
| `notte_step` | Execute an action on the current page |

### Agent Operations

| Tool | Description |
|------|-------------|
| `notte_operator` | Run a Notte agent to complete a task on any website |

## Getting Started

1. Install the required dependencies:
```bash
pip install notte-mcp
```

2. Set up your environment variables:
```bash
export NOTTE_API_KEY="your-api-key"
```

3. Start the MCP server:
```bash
python -m notte_mcp.server
```

> note: you can also start the dev server locally using `uv run mcp dev packages/notte-mcp/src/notte_mcp/server.py  --with-editable .`

To use the MCP in cursor or claude computer use, you can use the following json:

> check out the `$HOME/Library/Application Support/Claude/claude_desktop_config.json` file to see the installed MCP servers.
> note you might need to install the mcp-remote package using `npx mcp-remote`
```json
{
  "notte-mcp": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:8001/sse"
      ],
      "env": {
        "NOTTE_API_KEY": "<your-notte-api-key>"
      }
	}
}
```

## Claude Desktop examples:


```
> Can you look for the price of airforce 1 on the nike website (men's section) ? Please show me the browser visualizer so that I can track the progress live
> Can ou check out if I have any notte session active at the moment ?
```


## Cursor examples:
notte-llm 1.8.5
LLM integration for Notte
Requires Python: >=3.11

# notte-llm

LLM integration for Notte, providing LiteLLM-based services for language model interactions.

This package contains:
- LLM engine and service implementations
- Prompt management and templating
- LLM usage tracing and logging
- Structured output support

## Installation

```bash
pip install notte-llm
```

## Usage

```python
from notte_llm.engine import LLMEngine
from notte_llm.service import LLMService

# Create an LLM engine
engine = LLMEngine(model="gpt-4o-mini")

# Create an LLM service
service = LLMService()
```
notte-browser 1.8.5
The web browser for LLMs agents
Requires Python: >=3.11

# Notte Browser

The browser component of the Notte agentic ecosystem, designed to provide a seamless interface between LLM agents and web browsing capabilities. This package serves as the foundational layer that enables AI agents to interact with web content in a structured and efficient manner.

## Features

- **Browser Management**: Handles browser sessions and windows using Playwright under the hood
- **DOM Processing**: Transforms web pages into structured, agent-friendly formats
- **Error Handling**: Robust error management for various browser-related scenarios
- **Configurable Options**: Flexible configuration for headless mode, user agents, proxies, and more
- **Security Controls**: Built-in web security controls and customizable Chrome arguments

## Core Dependencies

- Python >=3.11
- notte_core
- patchright (Playwright-based browser automation)

## Usage

This package is typically used as part of the larger Notte ecosystem, providing the browser capabilities needed by Notte agents to navigate and interact with web content. It's designed to work seamlessly with other Notte components to enable sophisticated web automation and interaction scenarios.

For more information about the Notte ecosystem, visit [notte.cc](https://notte.cc).
ozobot-actors 0.2.0
Ozobot actor API package providing an alternative way for controling multiple bots
Requires Python: >=3.13

# ozobot-actors

Library that enables to control multiple Ozobot device using a globally defined functions. It mirrors the interface
of libraries implementing object oriented control of the individual robots. The library is primarily intended to be used by the Python code
generated from Blockly programs, as its semantics follows the actor based use by the [Ozobot Editor](https://editor.ozobot.com),
but can be used even in projects written from scratch.

See the [monorepo](https://github.com/ozobot/python-libraries) for more details. 

## Installation
The library requires you to list all the robots to be supported, so for example to install Evo support, run
`pip install ozobot-actors[evo]`, to install both Ari and Evo support, run `pip install ozobot-actors[ari,evo]`.

The library currently supports:
 - [`ozobot-ari`](/ozobot-ari)
 - [`ozobot-evo`](/ozobot-evo)


## Usage
The library defines global functions that can control any robot supporting that specific functionality. Targeting a specific robot
can be done by using a context manager. When an API function is called, the context is searched for available robot and the function is
executed with the first matching robot. The robot selection follows a few simple rules:

 - Actors need to be registered in the dispatcher
 - Actors are put onto the stack as they are registered
 - Selecting an actor puts it on top of the current stack
 - Masking an actor removes it from the current stack
 - Stack is searched from the top
 - First robot having the required functionality is used, leaving the stack untouched


```python
import asyncio

from ozobot import actors
from ozobot.actors.linefollower import move
from ozobot.actors.userio import user_io_alert
from ozobot.ari import AriHandle
from ozobot.evo import EvoHandle

dispatcher = actors.ActorDispatcher()
actors.set_actor_dispatcher(dispatcher)

async def main() -> None:
  async with EvoHandle(name="OzoEvo-1234abcd") as e1, EvoHandle(name="Ari-ABCD") as a1:
    dispatcher.add("Evo_1", e1)
    dispatcher.add("Ari_1", a1)

    with dispatcher.actor("Ari_1"):  # this puts Ari onto the default stack
      await move(100, 50)  # moves Ari
      await user_io_alert("Hello from Ari!")  # displays message on Ari

      with dispatcher.actor("Evo_1"):  # this puts Evo on top of Ari
        await move(100, 50)  # moves Evo
        await user_io_alert("Hello again from Ari!")  # Ari shows the message, because Evo does not support `user_io_alert`
      # stepping out of the context manager block removes Evo from the top of the stack
      
      await move(-100, 50)  # moves Ari again


if __name__ == "__main__":
  asyncio.run(main())
```