semvec/pypi-packages huggingface dataset:
dc43-integrations 0.33.0.0
Runtime integrations built on dc43 service contracts
Requires Python: >=3.11

# dc43-integrations

The integration packages connect the dc43 service contracts to runtime platforms. Today the
Spark adapter ships here, and additional adapters can live alongside it while depending only
on the shared client contracts.

## Installation

Governance adapters depend on optional runtimes so deployments can opt in only when they
need a specific integration:

- `spark` installs the PySpark runtime.
- `lineage` installs OpenLineage helpers for emitting run events.
- `telemetry` installs the OpenTelemetry SDK used by governance span recording.

For example, to provision the full Spark governance stack (matching the configuration
used in CI) install all extras:

```bash
pip install "dc43-integrations[spark,lineage,telemetry]"
```
dc43-service-backends 0.33.0.0
Backend service implementations for dc43
Requires Python: >=3.11

# dc43-service-backends

Backend-facing components that fulfill the dc43 service contracts live in this
package. Install it alongside `dc43-service-clients` when wiring custom storage,
governance, or quality enforcement backends.

## Configuration

The service backend HTTP application reads its settings from TOML files. Refer
to [docs/service-backends-configuration.md](../../docs/service-backends-configuration.md)
for the supported options—including filesystem, SQL, Delta, Collibra stub, and
Collibra HTTP contract stores—alongside editable templates. The same
configuration file now controls the data-quality delegate (`local` or `http`),
pluggable execution engines (native, Great Expectations, Soda), and the
governance store (memory, filesystem, SQL, Delta, or HTTP).
dc43-core 0.33.0.0
Shared contract helpers for dc43 packages
Requires Python: >=3.11

# dc43-core

Shared Python utilities used across the dc43 packages. The helpers in this
package provide light-weight wrappers around the Open Data Contract Standard
(ODCS) and Open Data Product Standard (ODPS) models along with SemVer
manipulation utilities.  They previously lived inside the backend services and
are now published separately so clients, integrations, and services can share a
single implementation.
rica-server 0.0.1.dev3
Multi-threaded Reasoning for Large Language Models
Requires Python: >=3.12
Keywords: llms, pytorch, nlp

# RiCA: Multi-threaded Reasoning for Large Language Models

| [English](README.md) | [中文](docs/zh/README.md) |
| :--- | :--- |

[![Run in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/rica-team/rica-server/blob/main/demo.ipynb)

**RiCA** is a framework that enables Large Language Models (LLMs) to perform multi-threaded reasoning. It allows LLMs to call external tools, continue thinking while waiting for the results, and handle multiple tool calls concurrently.

## Key Features

- **Multi-threaded Reasoning**: LLMs can execute long-running tasks in the background without blocking their thought process.
- **Tool Integration**: Easily integrate external tools and APIs through a simple decorator-based routing system.
- **Real-time Interaction**: Observe the model's "thinking" process in real-time through token-by-token streaming.
- **Flexible and Extensible**: Designed to be adapter-based, allowing for easy integration with different LLM backends (e.g., Transformers, OpenAI).

## Getting Started

### Installation

You can install RiCA and its dependencies using pip:

```bash
pip install .[pt]
```

### Running the Demo

The `demo/example.py` script provides a simple example of how to use RiCA. To run it, first make sure you have the necessary dependencies installed, then run the following command from the project root:

```bash
PYTHONPATH=. python demo/example.py
```

You can also explore the `demo.ipynb` notebook for a more interactive experience.

## How it Works

RiCA works by introducing a "multi-threaded thinking" capability to LLMs. When an LLM needs to use an external tool, it can choose to run it in the background. While the tool is running, the LLM can continue to reason, process information, and even call other tools. When a background tool finishes, its result is seamlessly inserted back into the LLM's context, allowing it to incorporate the new information into its reasoning process.

## Documentation

- [Development Guide](docs/en/DEVELOPMENT.md)
- [Contributing Guidelines](CONTRIBUTING.md)