Allowed Imports

Support for Agents Code

Whenever you code your Agents on Agentverse, you will have to do this on the Agent Editor. This Editor allows you to create any Agent application using a set of different imports available on the Agentverse platform. This resource helps you in understanding what’s available and what’s not.

On Agentverse, you can now import the Agent class and create your agent with my_agent = Agent(...). Note that this is simply a wrapper for your pre-loaded agent instance, so any custom configuration you add to the Agent will be ignored. This is because the configuration, seed, name, and address for hosted Agents is already set, and is not allowed to be overwritten.

Additionally, you can now use agent.run() method, but this is also not required. Clicking Run will cause your agent to run whether you include this command or not. The main reason for supporting this is to unify local and hosted Agent code, so that your Agent code can run as either local or hosted without any modifications.

Exceptions:

• Use of Bureau is not allowed as each Agent project can contain only a single Agent.

uagents

Build fast and lightweight for decentralized scenarios using the uagents Framework. Check out the uAgents documentation:

• Available classes: Model, Context, Protocol.

  Example:

  copy

  1
  from uagents import Context, Model
  2
  3
  class Message(Model):
  4
      text: str
  5
  6
  @agent.on_interval(period=2.0)
  7
  async def print_message(ctx: Context):
  8
      msg = Message(text=f"Hello there my wallet address is {ctx.wallet}.")
  9
      print(msg.text)

requests

This package allows you to interact with HTTP requests and responses.

• Available functions: get, post, put, patch, delete.

  Example:

  copy

  1
  import requests
  2
  3
  response = requests.get('https://api.github.com')
  4
  if response.status_code == 200:
  5
      print('Success!')
  6
  elif response.status_code == 404:
  7
      print('Not Found.')
  8
  9
  print(response.headers)

cosmpy

A Python library for interacting with Cosmos-based blockchains. Checkout the CosmPy documentation:

• Full access to all functions and features.

  Example:

  copy

  1
  from cosmpy import aerial
  2
  3
  # Define network configuration, faucet and ledger
  4
  network = aerial.client.NetworkConfig.fetchai_stable_testnet()
  5
  faucet_api = aerial.faucet.FaucetApi(network)
  6
  ledger = aerial.client.LedgerClient(network)
  7
  8
  MINIMUM_BALANCE = 100000000000000000
  9
  10
  @agent.on_interval(period=20.0)
  11
  async def get_tokens(ctx: Context):
  12
  13
      agent_balance = ledger.query_bank_balance(ctx.wallet)
  14
  15
      if agent_balance < MINIMUM_BALANCE:
  16
          print("Providing wealth to agent...")
  17
          faucet_api.get_wealth(ctx.wallet)

pydantic

A package to ensure data validation and settings management. It simplifies the process of defining and validating data models by providing a way to declare and enforce data types, constraints, and validation rules on Python data structures.

• Full access to all functions and features.

  Example:

  copy

  1
  from pydantic import BaseModel
  2
  3
  data = {
  4
      "name": "alice",
  5
      "age": 21
  6
  }
  7
  8
  class User(BaseModel):
  9
      name: str
  10
      age: int
  11
  12
  user = User(**data)
  13
  14
  print(user)

pymongo

pymongo allows Python applications to interact with MongoDB databases, making it easy to perform various database operations such as inserting, updating, deleting, and querying documents.

• Full access to all functions and features.

  Example:

  copy

  1
  from pymongo import MongoClient
  2
  3
  # Connect to MongoDB server
  4
  client = MongoClient('mongodb://localhost:27017/')
  5
  6
  # Access a specific database
  7
  db = client['my_database']
  8
  9
  # Access a specific collection within the database
  10
  collection = db['my_collection']
  11
  12
  # Insert a document into the collection
  13
  document = {'name': 'John', 'age': 30, 'city': 'New York'}
  14
  collection.insert_one(document)
  15
  16
  # Query documents from the collection
  17
  query = {'city': 'New York'}
  18
  result = collection.find(query)
  19
  20
  # Print the documents returned by the query
  21
  for doc in result:
  22
    print(doc)
  23
  24
  # Close the connection to MongoDB
  25
  client.close()

bs4 (BeautifulSoup)

bs4 make it easy to parse and interact with HTML and XML documents for web scraping or data extraction.

Example:

1
from bs4 import BeautifulSoup
2
import requests
3
4
# Fetch the content of a webpage
5
response = requests.get("https://example.com")
6
7
# Parse the HTML content
8
soup = BeautifulSoup(response.content, "html.parser")
9
10
# Extract and print the page title
11
print(soup.title.string)

fetchai-babble

fetchai-babble allows you to interact with the Fetch.ai messaging service (called Memorandum):

Example:

1
from babble import Client, Identity
2
3
# create a set of agents with random identities
4
client1 = Client('agent1.....', Identity.generate())
5
client2 = Client('agent1.....', Identity.generate())
6
7
# send a message from one client to another
8
client1.send(client2.delegate_address, "why hello there")
9
10
# receive the messages from the other client
11
for msg in client2.receive():
12
    print(msg.text)

langchain-anthropic

langchain-anthropic contains the LangChain integration for Anthropic’s generative models:

Example:

1
from langchain_anthropic import ChatAnthropic
2
from langchain_core.messages import AIMessage, HumanMessage
3
4
model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0, max_tokens=1024)
5
6
message = HumanMessage(content="What is the capital of France?")
7
8
response = model.invoke([message])

langchain-community

langchain-community contains third-party integrations that implement the base interfaces defined in LangChain Core, making them ready-to-use in any LangChain application. It is automatically installed by langchain, but can also be used separately:

Example:

1
import bs4
2
from langchain_community.document_loaders import WebBaseLoader
3
4
# Only keep post title, headers, and content from the full HTML.
5
bs4_strainer = bs4.SoupStrainer(class_=("post-title", "post-header", "post-content"))
6
loader = WebBaseLoader(
7
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
8
    bs_kwargs={"parse_only": bs4_strainer},
9
)
10
docs = loader.load()
11
12
len(docs[0].page_content)

langchain-core

langchain-core contains the base abstractions that power the rest of the LangChain ecosystem:

Example:

1
from langchain_core.messages import HumanMessage
2
from langchain_google_genai import ChatGoogleGenerativeAI
3
4
llm = ChatGoogleGenerativeAI(model="gemini-2.5-pro")
5
6
# example
7
message = HumanMessage(
8
    content=[
9
        {"type": "text", "text": "What's in this image?"},
10
        {"type": "image_url", "image_url": "https://picsum.photos/seed/picsum/200/300"},
11
    ]
12
)
13
llm.invoke([message])

langchain-google-genai

langchain-google-genai contains the LangChain integrations for Gemini through their generative-ai SDK:

Example:

1
from langchain_core.messages import HumanMessage
2
from langchain_google_genai import ChatGoogleGenerativeAI
3
4
llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash-image")
5
6
message = HumanMessage(
7
    content=[
8
        {"type": "text", "text": "Describe this image in one sentence."},
9
        {"type": "image_url", "image_url": "https://picsum.photos/seed/picsum/200/300"},
10
    ]
11
)
12
llm.invoke([message])

langchain-google-vertexai

langchain-google-vertexai contains the LangChain integrations for Google Cloud generative models:

Example:

1
from langchain_core.messages import HumanMessage
2
from langchain_google_vertexai import ChatVertexAI
3
4
llm = ChatVertexAI(model_name="gemini-2.5-pro")
5
6
message = HumanMessage(
7
    content=[
8
        {"type": "text", "text": "What's in this image?"},
9
        {"type": "image_url", "image_url": {"url": "https://picsum.photos/seed/picsum/200/300"}},
10
    ]
11
)
12
llm.invoke([message])

langchain-openai

langchain-openai contains the LangChain integrations for OpenAI through their openai SDK:

Example:

1
from langchain_openai import ChatOpenAI
2
3
llm = ChatOpenAI(
4
    model="gpt-4o",
5
    temperature=0,
6
    max_tokens=None,
7
    timeout=None,
8
    max_retries=2,
9
    # api_key="...",  # if you prefer to pass api key in directly instaed of using env vars
10
    # base_url="...",
11
    # organization="...",
12
    # other params...
13
)

langchain-text-splitters

langchain-text-splitters contains utilities for splitting into chunks a wide variety of text documents:

Example:

1
from langchain_text_splitters import RecursiveCharacterTextSplitter
2
3
text_splitter = RecursiveCharacterTextSplitter(
4
    chunk_size=1000, chunk_overlap=200, add_start_index=True
5
)
6
all_splits = text_splitter.split_documents(docs)
7
8
len(all_splits)

langchain

langchain assists in the development of applications integrating with LLMs:

Example:

1
import bs4
2
from langchain import hub
3
from langchain_chroma import Chroma
4
from langchain_community.document_loaders import WebBaseLoader
5
from langchain_core.output_parsers import StrOutputParser
6
from langchain_core.runnables import RunnablePassthrough
7
from langchain_openai import OpenAIEmbeddings
8
from langchain_text_splitters import RecursiveCharacterTextSplitter
9
10
# Load, chunk and index the contents of the blog.
11
loader = WebBaseLoader(
12
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
13
    bs_kwargs=dict(
14
        parse_only=bs4.SoupStrainer(
15
            class_=("post-content", "post-title", "post-header")
16
        )
17
    ),
18
)
19
docs = loader.load()
20
21
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
22
splits = text_splitter.split_documents(docs)
23
vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())
24
25
# Retrieve and generate using the relevant snippets of the blog.
26
retriever = vectorstore.as_retriever()
27
prompt = hub.pull("rlm/rag-prompt")
28
29
def format_docs(docs):
30
    return "\n\n".join(doc.page_content for doc in docs)
31
32
rag_chain = (
33
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
34
    | prompt
35
    | llm
36
    | StrOutputParser()
37
)
38
39
rag_chain.invoke("What is Task Decomposition?")

nltk

nltk is a package for natural language processing.

Example:

1
import nltk
2
nltk.download('punkt')
3
4
from nltk.tokenize import word_tokenize
5
6
text = "This is an example sentence, showing off the tokenization process."
7
8
tokens = word_tokenize(text)
9
10
print(tokens)
11
12
# ['This', 'is', 'an', 'example', 'sentence', ',', 'showing', 'off', 'the', 'tokenization', 'process', '.']

openai

openai provides easy access to the OpenAI REST API. The library includes type definitions for all request params and response fields, and offers both synchronous and asynchronous clients powered by httpx.

Example:

1
import os
2
from openai import OpenAI
3
4
client = OpenAI(
5
    # This is the default and can be omitted
6
    api_key=os.environ.get("OPENAI_API_KEY"),
7
)
8
9
chat_completion = client.chat.completions.create(
10
    messages=[
11
        {
12
            "role": "user",
13
            "content": "Say this is a test",
14
        }
15
    ],
16
    model="gpt-3.5-turbo",
17
)

tenacity

tenacity is a general-purpose retrying library to simplify the task of adding retry behavior to just about anything.

Example:

1
import random
2
from tenacity import retry
3
4
@retry
5
def do_something_unreliable():
6
    if random.randint(0, 10) > 1:
7
        raise IOError("Broken sauce, everything is hosed!!!111one")
8
    else:
9
        return "Awesome sauce!"
10
11
print(do_something_unreliable())

unstructured

unstructured is a library for processing and extracting data from unstructured file formats such as PDFs, Word documents, and more.

Example:

1
from unstructured.partition.auto import partition
2
3
elements = partition(filename="example-docs/fake-email.eml")
4
print("\n\n".join([str(el) for el in elements]))

validators

validators is a Python library designed for data validation. It provides simple functions to verify the validity of various types of data:

Example:

1
import validators
2
print(validators.email('someone@example.com'))  # True
3
print(validators.email('invalid-email'))  # ValidationFailure

web3

web3 is a Python library for interacting with the Ethereum blockchain. It provides functionalities for sending transactions, interacting with smart contracts, and querying blockchain data:

Example:

1
from web3 import Web3
2
3
w3 = Web3(Web3.HTTPProvider("https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID"))
4
5
print(w3.is_connected())  # True if connected to Ethereum network

anthropic

anthropic is a Python SDK for interacting with Anthropic’s AI models, such as Claude. It allows developers to send prompts, configure responses, and integrate natural language processing into their applications.

Example:

1
from anthropic import Anthropic
2
3
client = Anthropic(api_key="YOUR_ANTHROPIC_API_KEY")
4
5
response = client.messages.create(
6
    model="claude-3-haiku-20240307",
7
    max_tokens=50,
8
    messages=[
9
        {"role": "user", "content": "Tell me a joke about cats"}
10
    ]
11
)
12
13
print(response.content[0].text)

mcp

mcp (Model Context Protocol) is a specification and set of tools for connecting AI models with external data sources, applications, and tools through a unified protocol. It allows developers to integrate AI assistants with structured APIs and real-time services.

Example:

1
from mcp import Client
2
3
# Connect to an MCP server
4
client = Client("ws://localhost:5000")
5
client.connect()
6
7
# Send a query to a connected MCP tool
8
response = client.request("weather.get_forecast", {"location": "London"})
9
print(response)

httpx

httpx is a fully featured HTTP client for Python, supporting HTTP/1.1, HTTP/2, connection pooling, timeouts, streaming, and async requests. It’s a modern alternative to requests with built-in async support.

Example:

1
import httpx
2
3
# Synchronous request
4
response = httpx.get("https://api.github.com")
5
print(response.status_code, response.json())
6
7
# Asynchronous request
8
import asyncio
9
10
async def fetch():
11
    async with httpx.AsyncClient() as client:
12
        resp = await client.get("https://api.github.com")
13
        print(resp.status_code, resp.json())
14
15
asyncio.run(fetch())

asyncpg

asyncpg is an asynchronous PostgreSQL client library for Python, designed for high-performance database interactions.

Example:

1
import asyncio
2
import asyncpg
3
4
async def main():
5
    conn = await asyncpg.connect("postgresql://user:password@localhost/dbname")
6
    rows = await conn.fetch("SELECT 1 AS num")
7
    print(rows)
8
    await conn.close()
9
10
asyncio.run(main())

faiss-cpu

faiss-cpu is a library for efficient similarity search and clustering of dense vectors, optimized for CPUs.

Example:

1
import faiss
2
import numpy as np
3
4
data = np.random.random((5, 3)).astype("float32")
5
index = faiss.IndexFlatL2(3)
6
index.add(data)
7
8
D, I = index.search(data, 2)
9
print(I)

google-genai

google-genai is Google’s client for accessing Gemini models and other generative AI features.

Example:

1
from google import genai
2
3
client = genai.Client(api_key="your_api_key")
4
5
resp = client.models.generate_content(
6
    model="gemini-2.5-flash",
7
    contents="Say hello from the latest Gemini model!"
8
)
9
10
print(resp.text)

huggingface-hub

huggingface-hub provides utilities to interact with the Hugging Face Hub, allowing you to download and upload models, datasets, and spaces.

Example:

1
from huggingface_hub import snapshot_download
2
3
local_dir = snapshot_download(repo_id="bert-base-uncased")
4
print(local_dir)

langgraph

langgraph is a framework for building stateful, graph-based workflows around LLMs using LangChain primitives.

Example:

1
from langgraph.graph import StateGraph, END
2
3
builder = StateGraph(dict)
4
5
def step(state): 
6
    print("Running step with:", state)
7
    return {"done": True}
8
9
builder.add_node("start", step)
10
builder.set_entry_point("start")
11
builder.add_edge("start", END)
12
13
graph = builder.compile()
14
graph.invoke({"input": "hello"})

pypdf

pypdf is a pure-Python library for reading, manipulating, and writing PDFs.

Example:

1
from pypdf import PdfReader
2
3
reader = PdfReader("example.pdf")
4
print(len(reader.pages))
5
print(reader.pages[0].extract_text())

Additional Supported Packages

uagents-core

It contains the core components and abstractions used by the uAgents framework.

agentverse-client

Client library for interacting with the Agentverse platform.

aiofiles

Asynchronous file handling for Python.

aiohappyeyeballs

Implements the “Happy Eyeballs” algorithm for concurrent IPv4/IPv6 connection attempts.

aiohttp

Asynchronous HTTP client/server framework.

aiohttp-retry

Retry support for aiohttp requests.

aiosignal

Signal handling helpers for asyncio programs.

annotated-types

Runtime-usable type annotations, extending Python typing.

anyio

Asynchronous compatibility layer across asyncio, trio, and curio.

attrs

Declarative, boilerplate-free class creation library.

backoff

Function decorator for retrying with exponential backoff.

beautifulsoup4

HTML and XML parser for web scraping.

bech32

Implementation of Bech32 encoding/decoding, used in blockchain addresses.

bitarray

Efficient arrays of booleans stored as bits.

Bottleneck

Fast array operations for NumPy.

cachetools

Extensible caching collections and decorators.

certifi

Root certificates for SSL validation.

cffi

Foreign Function Interface for calling C code from Python.

chardet

Character encoding detector.

charset-normalizer

Alternative to chardet for encoding detection.

ckzg

Cryptographic library for polynomial commitments (KZG).

click

Package for creating command-line interfaces.

coincurve

Cryptographic library for elliptic curve operations (secp256k1).

cryptography

General-purpose cryptography library for Python.

cytoolz

Cython implementation of toolz for fast functional utilities.

dataclasses-json

JSON support for dataclasses.

distlib

Distribution utilities for Python packaging.

distro

Linux distribution information library.

dnspython

DNS toolkit for Python.

docstring_parser

Parse Python docstrings into structured data.

ecdsa

Elliptic Curve Digital Signature Algorithm library.

eciespy

Elliptic Curve Integrated Encryption Scheme for Python.

emoji

Library for handling emojis in Python.

eth_abi

Ethereum ABI encoding/decoding.

eth-account

Ethereum account management.

eth-hash

Ethereum-specific hashing utilities.

eth-keyfile

Ethereum keyfile management.

eth-keys

Ethereum key utilities.

eth-rlp

Ethereum RLP encoding/decoding.

eth-typing

Ethereum-specific typing definitions.

eth-utils

General Ethereum utilities.

fetchai-babble

Messaging protocol used in Fetch.ai agents.

ffmpeg

Python wrapper for executing FFmpeg commands for audio/video processing.

filelock

Cross-platform file locking library.

filetype

Infer file type and MIME type from binary data.

frozenlist

Immutable list implementation for async frameworks.

fsspec

Filesystem specification for unified file access.

google-ai-generativelanguage

Google API client for Generative Language models.

google-api-core

Core utilities for Google API clients.

google-auth

Authentication library for Google APIs.

google-cloud-aiplatform

Google Cloud AI Platform client library.

google-cloud-bigquery

BigQuery client library.

google-cloud-core

Shared library for Google Cloud Python clients.

google-cloud-resource-manager

Client for Google Cloud Resource Manager.

google-cloud-storage

Client for Google Cloud Storage.

google-crc32c

CRC32C checksum implementation.

google-resumable-media

Support for resumable uploads and downloads.

googleapis-common-protos

Common protocol buffer definitions for Google APIs.

greenlet

Lightweight in-process concurrent coroutines.

grpc-google-iam-v1

IAM policy API client for gRPC.

grpcio

gRPC framework for Python.

grpcio-status

Status code utilities for gRPC.

h11

HTTP/1.1 protocol library.

hexbytes

Hexadecimal byte representation for Ethereum.

html5lib

HTML parser based on the WHATWG specification.

httpcore

Low-level HTTP client library used by httpx.

httpx-sse

Server-Sent Events (SSE) extension for httpx.

idna

Internationalized Domain Names in Applications (IDNA) support.

jiter

Fast JSON parser.

joblib

Lightweight pipelining and parallelism library.

jsonpatch

Implementation of JSON Patch standard.

jsonpointer

Implementation of JSON Pointer standard.

jsonschema

Validation of JSON documents against schemas.

jsonschema-specifications

Base specifications for JSON Schema.

langdetect

Language detection library.

langgraph-checkpoint

Checkpointing utilities for LangGraph.

langgraph-prebuilt

Prebuilt components for LangGraph workflows.

langgraph-sdk

SDK for working with LangGraph.

langsmith

LangChain observability and evaluation platform.

lru-dict

Fast, pure-Python LRU (Least Recently Used) dictionary.

lxml

High-performance XML and HTML library.

marshmallow

Object serialization/deserialization library.

multidict

Multi-value dictionary implementation.

mypy_extensions

Extensions to Python typing for mypy.

numexpr

Fast array expression evaluator.

numpy

Core scientific computing library.

olefile

Parser for OLE (Object Linking and Embedding) files.

orjson

Fast JSON parser and serializer.

ormsgpack

Optimized MessagePack serializer/deserializer.

packaging

Utilities for version and dependency handling.

parsimonious

PEG parser library.

pip

Python package installer.

platformdirs

Determine platform-specific directories.

propcache

Property caching decorator.

proto-plus

Pythonic interface to protocol buffers.

protobuf

Google’s protocol buffers implementation.

psutil

Process and system monitoring utilities.

py-ecc

Elliptic curve cryptography for Ethereum.

pyarrow

Apache Arrow Python bindings.

pyasn1

ASN.1 data structures and codecs.

pyasn1_modules

Common ASN.1 modules.

pycparser

C parser in pure Python.

pycryptodome

Cryptographic library as a drop-in for PyCrypto.

pydantic_core

Core validation logic for Pydantic.

pydantic-settings

Settings management with Pydantic.

PyJWT

JSON Web Token implementation in Python.

python-dateutil

Date/time utilities.

python-dotenv

Loads environment variables from .env files.

python-iso639

Utilities for ISO 639 language codes.

python-magic

File type identification using libmagic.

python-multipart

Multipart parsing for form-data (file uploads).

python-oxmsg

OXMSG file parser.

pyunormalize

Unicode text normalization utilities.

PyYAML

YAML parser and emitter.

RapidFuzz

Fuzzy string matching.

referencing

JSON schema reference resolution.

regex

Alternative regular expression engine.

requests-toolbelt

Extensions for the requests library.

rlp

Recursive Length Prefix (RLP) encoding for Ethereum.

rpds-py

Immutable data structures in Rust for Python.

rsa

RSA cryptographic library.

shapely

Geometry manipulation and analysis library.

six

Compatibility utilities between Python 2 and 3.

sniffio

Detect currently running async library.

sortedcontainers

Sorted collection types.

soupsieve

CSS selector library for BeautifulSoup.

SQLAlchemy

SQL toolkit and ORM.

sse-starlette

Server-Sent Events (SSE) support for Starlette.

starlette

ASGI framework for building web apps.

tiktoken

Tokenizer for OpenAI models.

toolz

Functional programming utilities.

tqdm

Progress bar library.

typing_extensions

Backports of newer typing features.

typing-inspect

Inspection utilities for typing objects.

typing-inspection

Additional runtime inspection for typing.

uagents-adapter

Adapter tools for uAgents framework.

uagents-ai-engine

AI Engine integration for uAgents.

unstructured-client

Client library for the Unstructured data processing API.

urllib3

HTTP client library.

uvicorn

ASGI server implementation.

virtualenv

Virtual environment manager.

webencodings

Web encoding standards for HTML/CSS.

websockets

WebSocket client and server library.

wrapt

Function decorators and wrappers.

yarl

URL parsing and manipulation library.

zstandard

Zstandard compression library.