semvec/pypi-packages huggingface dataset:
chatbot-kernel 0.4.1
A Jupyter kernel using LLM models from Huggingface
Requires Python: >=3.8

# chatbot_kernel
A Jupyter kernel to use Jupyter as a chat window, running downloaded LLMs locally.

## Installation
This kernel package can be install from PyPI
```
$ pip install chatbot_kernel
```

Once the package installed, the kernel spec can be installed to home directory by command:
```
$ python -m chatbot_kernel install --user
```
If you are using virtualenv, do
```
$ python -m chatbot_kernel install --sys-prefix
```
instead.

If you install the package to a virtual environment, you may need to set up `JUPYTER_PATH=/path/to/venv/share/jupyter:$JUPYTER_PATH` so that jupyter can find the kernel

## Usage
A few magics are available in the kernel:
- `%help`: Print help messages
- `%config`: Set advanced configuration. See more in `%config help`
- `%load`: Load a pretrained LLM
- `%hf_home`: Set the path to find downloaded LLMs, similar to set `HF_HOME` environment variable
- `%model_list`: Show the available LLMs
- `%new_chat`: Clean up the chat history

Before start chatting, you need to at least download a model from [HuggingFace](https://huggingface.co/docs/hub/models-downloading). For example, `huggingface-cli download meta-llama/Meta-Llama-3-8B-Instruct`.
Once models are downloaded, launch a jupyter notebook/lab and execute `%load <model>` and start chatting. Here is an example:
```
%load meta-llama/Meta-Llama-3-8B-Instruct
hi 
who are you
```

## Caveat
Currently, the kernel use the `AutoModelForCausalLM` and it is not supported by all models.
A few models have been tested:
- `meta-llama/Meta-Llama-3-8B-Instruct`
- `mistralai/Mistral-7B-Instruct-v0.3`: needs `sentencepiece` dependency
- `unsloth/llama-3-8b-Instruct-bnb-4bit`: needs `bitsandbytes` dependency
vtide 0.1.0
VTide: A python package for variational Bayesian tidal harmonic analysis
Requires Python: >=3.6

A Python implementation of the variational Bayesian harmonic analysis proposed in https://doi.org/10.22541/essoar.172072179.92243659/v1. 

# Installation
```
pip install vtide
```
# Usage
## Standard Analysis
Suppose we have a pandas dataframe containing sea-level measurements with a date-time index containing the time of each measurement. A complete RTide analysis can be run in just three lines of code: 
```
df = pd.DataFrame({'observations': observations}, index = times)

model = VTide(df, lat, lon)
yp, sd = model.Solve()
```
A model has now been trained, and the constituents estimated from the provided data. Solve() will return two arrays, yp and sd which correspond to the tidal predictions and the associated standard deviations respectively. Solve has several additional functionalities, the most useful is the `prune' feature which will perform probabilistic outlier removal based on a user defined threshold. The fit results can be visualized using:
```
model.Visualize_Residuals()
```
If pruning it used, the bottom KDE plot will show the distribution of residuals without the outliers. This should be approximately Gaussian if things have gone right! We can now use the learned model to generate probabilistic predictions whenever we want. All we need is to provide a pandas time-index with the desired times:
```
yp, sd = model.Predict(test_times)
```

## Constituents
After calling Solve(), the derived constituents and associated uncertainty estimates can be accessed directly through a dictionary using:
```
consts = model.harmonics

amplitudes = [consts[const]['amp'] for const in consts]
amplitude_uncertainty = [consts[const]['amp_uncert'] for const in consts]
phases = [consts[const]['phase'] for const in consts]
phase_uncertainty = [consts[const]['phase_uncert'] for const in consts]
```
Constituents and confidence intervals can quickly be visualized by calling:
```
model.Visualize_Constituents()
```
ir-explain 0.1
A Python Library for Explainable IR methods
Requires Python: >=3.9

# ir_explain

## Installing requirements

```
git clone https://github.com/souravsaha/ir_explain.git
```
```
conda create -n ir_explain python=3.9
```
```
pip install .
```
Note that for now we have tested ir_explain on Python 3.9 and Java 11. we will test on newer versions of Python soon and update.

Before running the ir_explain library, set the JAVA HOME as follows (replace the path appropriately):
```
export JAVA_HOME="/usr/lib/jvm/java-11-openjdk-amd64/"
```

## Usage

As of now, we have established a single pipeline with pointwise component. 

### To get started 

You can run the programs test_point_wise.py, test_pair_wise.py, and test_list_wise.py to get the pipeline. 

## Contributing

IR Explain library is open-source, and we are open to all the contributions from IR and NLP community. If you find a bug please report to the issue tracker, even better to send us a pull-request on Github.
waldur-mcp-server 0.1.1
Waldur MCP server project
Requires Python: >=3.13

# Waldur MCP server

## Quickstart

1. Install Claude Desktop for your platform from the [Claude Desktop releases page](https://claude.ai/download)

2. Install Python 3.10 or higher.

3. Install uv package manager.

### Installation

To install the package:

```bash
pip install waldur-mcp-server
```

Or with uv:

```bash
uv pip install waldur-mcp-server
```

### Claude Desktop MCP Server Configuration

On Windows: `\AppData\Roaming\Claude\claude_desktop_config.json`

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>

```json
{
  "mcpServers": {
    "waldur-mcp-server": {
      "command": "uv",
      "args": [
        "--directory",
        "C:\\waldur_service",
        "run",
        "waldur-mcp-server"
      ],
      "env": {
        "WALDUR_API_URL": "https://your-waldur-instance/api",
        "WALDUR_TOKEN": "your-token"
      }
    }
  }
}
```

</details>

<details>
  <summary>Published Servers Configuration</summary>

```json
{
  "mcpServers": {
    "waldur-mcp-server": {
      "command": "uvx",
      "args": [
        "waldur-mcp-server"
      ],
      "env": {
        "WALDUR_API_URL": "https://your-waldur-instance/api",
        "WALDUR_TOKEN": "your-token"
      }
    }
  }
}
```

</details>

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).

You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory C:\\waldur_service run waldur-mcp-server
```

When debugging, you'll need to set the required environment variables. Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

## Development

For information about development and releasing new versions, see [RELEASING.md](RELEASING.md).