semvec/pypi-packages huggingface dataset:
xethhung12-minio-download-file 0.0.14
A small program downloading file to minio repo
Requires Python: >=3.7


# Build
```shell
rm -fr dist/*
python -m build
```

# Deploy
```shell
python twine upload dist/* -u __token__ -p {token}
```

# Usage 
```shell
python -m xethhung12_minio_download_file \
    --url {url} \
    --access-key {access-key} \
    --secret-key {secret-key} \
    --bucket {bucket} \
    --local-file {local file} \
    --remote-file {remote file}
```
xethhung12-minio-upload-file 0.0.14
A small program uploading file to minio repo
Requires Python: >=3.7


# Build
```shell
rm -fr dist/*
python -m build
```

# Deploy
```shell
python twine upload dist/* -u __token__ -p {token}
```

# Usage 
```python
python -m xethhung12_minio_upload_file \
    --url {url} \
    --access-key {access-key} \
    --secret-key {secret-key} \
    --bucket {bucket} \
    --local-file {local file} \
    --remote-file {remote file}
```
xethhung12-tg-msg 0.0.9
A small program for sending telegram message in quick
Requires Python: >=3.7

# Build and deploy
```shell
rm -fr dist/*
python -m build
python twine upload dist/* -u __token__ -p {token}
```

# Usage of simple sending
```shell
python -m xethhung12_tg_msg \
    --receiver-id {receiver-id} \
    --bot-token {bot-token} \
    --msg {message} 
    # --silent [if want the program close normally, eception still print out but return in normal return code]
```

# Usage  of sending through STDIN
```shell
python -m xethhung12_tg_msg \
    --receiver-id {receiver-id} \
    --bot-token {bot-token} \
    --from-stdin {stdin input} 
    # --silent [if want the program close normally, eception still print out but return in normal return code]
```
pyloom 0.0.3
A event sourcing framework for building large language model applications
Requires Python: >=3.9,<4.0

# 🧶 Pyloom

🪡 A event sourcing framework for building large language model applications 🪡

Pyloom is a framework designed to streamline the development of intricate LLM applications. Drawing inspiration from [event sourcing](https://martinfowler.com/eaaDev/EventSourcing.html), Pyloom applies this concept to the LLM agent development, offering a range of powerful features that enables better dev experience.

Developing intricate and non-deterministic LLM agents involves making multiple LLM calls and intricate control structures, similar to constructing a Marble 
Machine (🔮). If an error arises, developers are frequently compelled to rerun the entire agent workflow. Developers care not only the agent's final outcome but also the steps it takes to arrive there. At times, We want to see how tweaks like extra tools or adjusted prompts in-between can affect the final outcome.

Pyloom is crafted to address these challenges.

Features
- **"Git for Agent":** Pyloom tracks state changes and the evolution of the agent at each step.
- **Agent Replay:** With Pyloom, developers can replay and navigate through the agent's flow. Once encouter an error in the agent flow, you can fix the issue and restart from the exact point of failure.
- **Event Sourcing:** Pyloom employs event sourcing, representing agent actions as events. By replaying the event stream, the agent's state can be reconstructed. Furthermore, developer can apply the same event streams to different agents and compare performance.
- **Reproduce Production Issues:** Leveraging event sourcing, Pyloom facilitates the reproducing of production errors by replaying the identical event streams in development environment.


Pyloom can be used with other LLM frameworks like langchain and guidance.

## Installation
You can install Pyloom using pip:

```python
pip install pyloom
```

## Quick Start
- [tutorial](notebooks/tutorial.ipynb)

## Contributing
We are extremely open to contributions in various forms: bug fixes, new features, improved documentation, and pull requests. Your input is valuable to us!
dallm 0.0.6
Domain Adapted Language Model
Requires Python: >=3.7

# Arcee

:tulip:	The open source alignment toolkit for finetuning and deploying LLMs :tulip:

## Finetuning Datasets

The Arcee toolkit contains routines for you to manage and generate finetuning datasets. The arcee toolkit supports supervised finetuning (SFT) aka intruction tuning. 

### ✍️ Instruction Set ✍️

Instruction tuning datasets contain a series of prompt and completion examples.

Instruction sets can be loaded from a csv.

```
from arcee.data import InstructionSet
instruction_set = InstructionSet("./datasets/strip_api.csv")
```

Or downloaded from the Arcee platform

```
from arcee.data import InstructionSet
instruction_set = InstructionSet("https://app.arcee.ai/arcee/alpaca")
```

### Self-Instruct Generation

### Evolv-Instruct Genertation

### Explain-Instruct Generation


## Finetuning Models

### HuggingFace

```
from arcee.models import LM
from arcee.data import Instuctions

lm = LM("falcon30b")
instructions = Instructions("./datasets/stripe-api.json")
lm.train(instructions)

lm.predict("Place an order for the LLM-9000 product for 100 USD to the card 3007200039992000")
```

### OpenAI

### Cohere

### Together

### Mosaic ML

## LangChain Integration

```
from langchain import Arcee
#goes in llms/arcee.py

prompt_template = "Write a stripe API request for the following: {order}."

llm = Arcee(temperature=0)
llm_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template(prompt_template)
)
llm_chain("Place an order for the LLM-9000 product for 100 USD to the card 3007200039992000")
```

## Domain Pretraining

Coming soon!

## 🗻 Arcee Platform 🗻

Arcee offers a platform for managing your proprietary language models in production. We offer a version of our platform hosted in our cloud as well as a deployable version that you can take on prem.

### Authenticaiton

To use the arcee platform, visit https://app.arcee.com/api-settings and `export ARCEE_API_KEY=*******` in your environment.

### Dataset Managemnt

View, search, and edit datasets. 

```
instruction_set.upload("project-name")
```

### Hosted Training

### Hosted Inference

### Lifecycle Management