semvec/pypi-packages huggingface dataset:
agentforum 0.0.10
An asynchronous framework for building LLM-based multi-agent systems in Python, with a focus on trees of immutable messages and token streaming.
License: MIT
Requires Python: >=3.9,<4.0

# 🏛 AgentForum

An asynchronous framework for building LLM-based multi-agent systems in Python, with a focus on:

- **Message trees which highly resemble commits in git to facilitate backtracking.** Messages are immutable and are
  identified by hashes based on their content and their history (a hash of the previous message). A single hash
  represents state of a conversation at a given point in time.
- **Message promises and the possibility of token streaming.** `MessagePromise` objects are returned before the
  messages are fully generated. Token streaming is supported regardless of the number of nested levels of agents.

*NOTE: While this framework is designed with LLMs in mind, it can be used with any kind of agents.*

## 🧩 Features

- **Message forwarding.** Messages can be forwarded to become a part of different message branches or
  trees (much like it is done in messaging apps for humans).

## 💡 Philosophy

- **Agents run as concurrently as possible.** When an agent is called with `.call()` or `.quick_call()` a task is
  scheduled and `AgentCall` or `AsyncMessageSequence` objects are returned immediately. The actual processing will
  happen upon a task switch.
- **Stateless agents are encouraged.** This is not a hard requirement, but ideally the agents should produce the same
  output when they are given the same input (the same sequence of messages from a message branch).

## 🔧 Implementation details

This framework supports **Python 3.9 or higher** and uses [asyncio](https://docs.python.org/3/library/asyncio.html)
under the hood.

## 🌱 Future plans

- **Message replies.** Technically this will be very similar to message forwarding. The difference will mostly be
  semantic (in the spirit of mimicking messaging apps for humans).
- **Exceptions as part of the message tree.** In the future, exceptions raised by agents will be represented as a
  special type of messages and will be part of the message branches those agents were on when they were raised.
- **Optional caching of agent responses (enabled by default).** When the same sequence of messages is sent to an agent,
  the framework will respond with the same sequence of response messages without actually calling the agent.
- **Cancellation of agent execution.** In the future, it will be possible to cancel the execution of agents before
  they finish.

***⚠️ NOTE: These plans are tentative and may change in the future. ⚠️***
stac-api-load-balancing 0.2.0
Load balancing for stac compliant apis
License: MIT
Requires Python: >=3.7

# stac-api-load-balancing
Taurus and Locust load balancing tools for testing stac-api backends.

![Alt text](readme_files/taurus-pgstac.png?raw=true "stac-fastapi-pgstac")


## Run stac-fastapi backends locally (elasticsearch|opensearch|pgstac)
```$ docker-compose up pgstac```   
```$ docker-compose up app-pgstac```

## Install locally for development
```$ pip install -e .```  
    
## Install from PyPI   
```$ pip install stac-api-load-balancing```  

```
Usage: stac-api-load-balancing [OPTIONS]

  Entry point for the stac-api-load-balancing CLI tool.

  This tool facilitates data ingestion, Locust load testing, and Taurus
  performance testing against a specified STAC API endpoint.

  Args:     
  ingest (bool): If True, ingest sample data into the specified STAC API.     
  locust (bool): If True, execute Locust load tests against the
  specified STAC API.     
  taurus (bool): If True, perform Taurus performance
  testing with custom settings against the specified STAC API.     
  concurrency (int): Specifies the number of concurrent users for Taurus testing. Default is 10.      
  ramp_up (str): Specifies the ramp-up period for Taurus testing, in Taurus notation (e.g., '1m' for 1 minute). Default is '1m'.  
  iterations (int): Specifies the number of iterations each virtual user will
  execute in Taurus testing. Default is 100.     
  api_address (str): The base URL of the STAC API to be tested.

Options:
  -i, --ingest               Ingest sample data into the STAC API.
  -l, --locust               Run Locust load tests against the STAC API.
  -t, --taurus               Run the Taurus wrapper for performance testing
                             against the STAC API.
  -c, --concurrency INTEGER  Number of concurrent users for Taurus option.
  -r, --ramp-up TEXT         Ramp-up time for Taurus option.
  -n, --iterations INTEGER   Number of iterations for Taurus option.
  -a, --api-address TEXT     Specify the STAC API URL to test against.
  --version                  Show the version and exit.
  --help                     Show this message and exit.
```

## Ingest test data - http://localhost:8084 is just an example url
```$ stac-api-load-balancing --ingest --api-address http://localhost:8084```

## Run Locust Load Balancing Ouside of Taurus Wrapper
```$ stac-api-load-balancing --locust --api-address http://localhost:8084```  
- go to ```http://localhost:8089``` and start with desired settings

## Inside of Taurus Wrapper
```$ stac-api-load-balancing --taurus --api-address http://localhost:8084```

## Debugging Locust tasks using a single simulated user
```$ python stac_api_load_balancing/config_files/locustfile.py```