semvec/pypi-packages huggingface dataset:
rusticai-claude 1.1.0
Claude Integration
Requires Python: <3.14,>=3.13

# claude

Claude Integration

## Configure claude code to use vertex ai
Set the following environment variables:

```bash
export CLAUDE_CODE_USE_VERTEX=1
export CLOUD_ML_REGION=global
export ANTHROPIC_VERTEX_PROJECT_ID=YOUR-PROJECT-ID
```

refer docs for more info: https://code.claude.com/docs/en/google-vertex-ai
rusticai-llm-agent 1.1.0
A complete set of LLM agents
Requires Python: <3.14,>=3.13

# Rustic AI LLMAgent

This module introduces a pluggable LLMAgent based on common patterns observed while using of language models within [Rustic AI](https://www.rustic.ai/) guilds.
The implementation leverages the Rustic AI's LLM dependency injection to allow for custom implementations of the LLM.

## Installing

```shell
pip install rusticai-llm-agent rusticai-litellm
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-vertexai 1.1.0
Rustic AI module with Vertex AI integrations
Requires Python: <3.14,>=3.13

# Rustic AI VertexAI

Rustic AI module supporting integration with [Vertex AI](https://cloud.google.com/vertex-ai)

## Prerequisites
1. Using this module requires a Google Cloud Account project with Vertex AI API enabled. The account must have the role `Vertex AI User`.
2. `gcloud CLI` for local development.

## Installing

```shell
pip install rusticai-vertexai
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```

## Usage
The library also supports using environment variables `VERTEXAI_PROJECT` and `VERTEXAI_LOCATION` in addition to the ones supported by [Google Cloud AI Platform SDK](https://cloud.google.com/python/docs/reference/aiplatform/latest) 
```shell
export VERTEXAI_PROJECT=<project-id>
export VERTEXAI_LOCATION=<location>
```

For local development/use, ensure the account you are using has the roles/permissions of `Vertex AI User` and `Service Usage Consumer` at the minimum.
Login using `gcloud CLI` in a terminal
```shell
gcloud auth application-default login
gcloud auth application-default set-quota-project <project-id>
```
For more options/details, [refer Google Cloud docs](https://cloud.google.com/docs/authentication/set-up-adc-local-dev-environment).

On Cloud, It's recommended to use Google Workload Identity.
rusticai-langchain 1.1.0
Rustic AI module with LangChain integrations
Requires Python: <3.14,>=3.13

# Rustic AI LangChain

Rustic AI module with [LangChain](https://www.langchain.com/) integrations.

## Installing

```shell
pip install rusticai-langchain
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/).


## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-huggingface 1.1.0
Rustic AI module with huggingface integrations
Requires Python: <3.14,>=3.13

# Rustic AI Hugging Face

[Rustic AI](https://www.rustic.ai/) module which provides agents and mixin leveraging [Hugging Face](https://huggingface.co/).

## Installing

```shell
pip install rusticai-huggingface # depends on [rusticai-core](https://pypi.org/project/rusticai-core/).
```

**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/) and uses Pytorch CPU dependency by default.

For models that require authentication, set the environment variable `HF_TOKEN` or use the [huggingface-cli](https://huggingface.co/docs/huggingface_hub/en/quick-start#authentication)

## Building from Source

```shell
poetry install --with dev --all-extras
poetry build
```
rusticai-playwright 1.1.0
Rustic AI module for scraping using playwright
Requires Python: <3.14,>=3.13

# Rustic AI Playwright

This module employs [Playwright](https://playwright.dev/python/docs/intro) to facilitate web scraping tasks.

## Installing

```shell
pip install rusticai-playwright
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-serpapi 1.1.0
Rustic AI module supporting Search through SerpApi
Requires Python: <3.14,>=3.13

# Rustic AI SerpApi

This module provides an agent that can be used to Search the web using [SerpApi](https://serpapi.com/)


## Installing

```shell
pip install rusticai-serpapi
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-marvin 1.1.0
Rustic AI module using Marvin
Requires Python: <3.14,>=3.13

# Rustic AI Marvin

[Rustic AI](https://www.rustic.ai/) module which provides text classification and extraction agent using [Marvin](https://www.askmarvin.ai/welcome/what_is_marvin/).

## Installing

```shell
pip install rusticai-marvin
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

Marvin by default uses OpenAI, but it can be configured to use other providers. For example, to use Gemini, 
```shell
export MARVIN_AGENT_MODEL=google-vertex:gemini-2.0-flash
```

Refer [Marvin Docs](https://askmarvin.ai/guides/configure-llms) for more on this.

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-chroma 1.1.0
Rustic AI module for leveraging ChromaDB
Requires Python: <3.14,>=3.13

# Rustic AI Chroma

This module provides a [Chroma](https://docs.trychroma.com/docs/overview/introduction) implementation of [Rustic AI](https://www.rustic.ai/)'s vectorstore.

## Installing

```shell
pip install rusticai-chroma
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-litellm 1.1.0
Rustic AI module leveraging LiteLLM for LLMs
Requires Python: <3.14,>=3.13

# Rustic AI LiteLLM

This module offers seamless integration with various LLMs through [LiteLLM](https://docs.litellm.ai/docs/), simplifying the use of language models within [Rustic AI](https://www.rustic.ai/) guilds.

## Installing

```shell
pip install rusticai-litellm
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-api 1.1.0
API Server for Rustic AI
Requires Python: <3.14,>=3.13

# Rustic AI API
This module provides the backend server for the Rustic AI framework. It provides the interface for creating and interacting with guilds.
The interaction with a guild is supported through a Websocket interface, allowing for real-time communication and updates.

## Installing

```shell
pip install rusticai-api
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/) and [rusticai-ray](https://pypi.org/project/rusticai-ray/).

## Running from source

1. Install required dependencies:
```shell
poetry install --with dev
poetry shell
```

2. Start the server:
```shell
# If using an external SQL database, expose RUSTIC_METASTORE to the corresponding url 
# For example, if using postgres, export RUSTIC_METASTORE=postgresql+psycopg://user:pwd@localhost:5432
./scripts/dev_server.sh
```

Server will be available at `http://localhost:8880` by default. The API documentation can be accessed at `http://localhost:8880/docs`.

## Running from source with Telemetry

1. Install required dependencies:
```shell
poetry install --with dev
poetry shell
```

2. Start Zipkin server - requires [Docker](https://www.docker.com/get-started/)
```shell
sudo chmod 777 scripts/zipkin/data-tmp/
./scripts/zipkin/zipkin_up.sh
```

3. Set the otel env variables -
```shell
export OTEL_SERVICE_NAME=GuildCommunicationService
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="http://localhost:4318/v1/traces"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
```
Refer [docs](https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/#endpoint-configuration)
for details.

3. Start the server -
```shell
./scripts/dev_server_with_otel.sh
```
Traces will be visible in Zipkin UI at http://localhost:9411/zipkin/

Note: To stop the Zipkin server, use `./scripts/zipkin/zipkin_down.sh`

**To run with all the available `rusticai` packages, use the poetry environment from the root directory, and prefix commands with `api/` — for example, use `./api/scripts/dev_server_with_otel.sh` instead of `./scripts/dev_server_with_otel.sh`.**
rusticai-ray 1.1.0
Rustic AI execution engine running on Ray Cluster
Requires Python: <3.14,>=3.13

# Rustic AI Ray

This module supports execution of [Rustic AI](https://www.rustic.ai/) on [Ray Cluster](https://docs.ray.io/en/latest/cluster/getting-started.html).

## Installing

```shell
pip install rusticai-ray
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-redis 1.1.0
Redis package for Rustic AI
Requires Python: <3.14,>=3.13

# Rustic AI Redis

This module provides a [Redis](https://redis.io/software/) based implementations of [Rustic AI](https://www.rustic.ai/)'s messaging backend, key value store, etc.

## Installing

```shell
pip install rusticai-redis
```
**Note:** It depends on [rusticai-core](https://pypi.org/project/rusticai-core/)

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-testing 1.1.0
Test Utilities for Rustic AI Framework
Requires Python: <3.14,>=3.13

# Rustic AI Testing

Rustic AI Testing is a collection of test utilities that can be leveraged to verify integration with Rustic AI Framework. 
**This should only be used for testing purposes and should not be used in production.**

## Installing

```shell
pip install rusticai-testing
```

## Building from Source

```shell
poetry install --with dev
poetry build
```
rusticai-core 1.1.0
Rustic AI’s modular, agentic AI framework for building human-centered, multi-agent workflows
Requires Python: <3.14,>=3.13

# Rustic AI Core

Rustic AI Core provides the foundational interfaces and components necessary for building human-centered, multi-agent
applications. 

## Installing

```shell
pip install rusticai-core
```

## Building from Source

```shell
poetry install --with dev
poetry build
```
llama-agents-server 0.2.0rc2
HTTP server for deploying and serving LlamaIndex workflows as web services
Requires Python: >=3.9

# LlamaAgents Server

HTTP server for deploying [LlamaIndex Workflows](https://pypi.org/project/llama-index-workflows/) as web services. Built on Starlette and Uvicorn.

## Installation

```bash
pip install llama-agents-server
```

## Quick Start

Create a server file (e.g., `my_server.py`):

```python
import asyncio
from workflows import Workflow, step
from workflows.context import Context
from workflows.events import Event, StartEvent, StopEvent
from llama_agents.server import WorkflowServer

class StreamEvent(Event):
    sequence: int

class GreetingWorkflow(Workflow):
    @step
    async def greet(self, ctx: Context, ev: StartEvent) -> StopEvent:
        for i in range(3):
            ctx.write_event_to_stream(StreamEvent(sequence=i))
        name = ev.get("name", "World")
        return StopEvent(result=f"Hello, {name}!")

server = WorkflowServer()
server.add_workflow("greet", GreetingWorkflow())

if __name__ == "__main__":
    asyncio.run(server.serve("0.0.0.0", 8080))
```

Or run it with the CLI:

```bash
llama-agents-server my_server.py
```

## Features

- REST API for running, streaming, and managing workflows
- Debugger UI automatically mounted at `/` for visualizing and debugging workflows
- Event streaming via newline-delimited JSON or Server-Sent Events
- Human-in-the-loop support for interactive workflows
- Persistence with built-in SQLite store (or bring your own via `AbstractWorkflowStore`)

## Client

Use [`llama-agents-client`](https://pypi.org/project/llama-agents-client/) to interact with deployed servers programmatically.

## Documentation

See the full [deployment guide](https://developers.llamaindex.ai/python/llamaagents/workflows/deployment/) for API details, persistence configuration, and more.
bi_etl 1.8.4
Python ETL Framework
Requires Python: >=3.10
Keywords: etl

# bi_etl Python ETL Framework for BI

[![pypi](https://img.shields.io/pypi/v/bi-etl.svg)](https://pypi.org/project/bi-etl/)
[![license](https://img.shields.io/github/license/arcann/config_wrangler.svg)](https://github.com/arcann/config_wrangler/blob/master/LICENSE)
[![Python package](https://github.com/arcann/bi_etl/actions/workflows/unit_test.yml/badge.svg)](https://github.com/arcann/bi_etl/actions/workflows/unit_test.yml)

## Docs

[Please see the documentation site for detailed documentation.](https://bietl.dev/bi_etl/)

Python based ETL (Extract Transform Load) framework geared towards BI databases in particular. 
The goal of the project is to create reusable objects with typical technical transformations used in loading dimension tables.

## Guiding Design Principles
1. Don’t Repeat Yourself (DRY).

1. The source or target of an ETL owns the metadata (list of columns and data types). The ETL generally has no reason to define those again unless the ETL requires a change. If a datatype must be changed, only that one column’s new type should be specified. If a column name must be changed, only the source & target column names that differ should be specified.

1. Data Quality is King

1. Data quality is more important than performance. For example, the process should fail before truncating data contents (i.e. loading 6 characters into a 5 character field) even if that means sacrificing some load performance.

1. Give helpful error messages.

1. Make it as easy as possible to create re-usable modules.

1. SQL is a very powerful transformation language. The Transform Extract Load (TEL) model should be supported.