semvec/pypi-packages huggingface dataset:
mcp-testaserver-http 0.1.3
Un servidor MCP que actúa como puente HTTP
Requires Python: >=3.10

# MCP ↔ HTTP Bridge

Servidor MCP local (stdio) que expone dinámicamente las tools de un servidor HTTP externo.

```
Cliente MCP (Claude Code / CLI)
        ↕  stdio
  mcp_server.py   ← servidor MCP local
        ↕  HTTP
  http_server.py  ← tu backend con las tools
```

---

## Requisitos

```bash
pip install mcp httpx fastapi uvicorn
```

---

## Arrancar

### 1. Servidor HTTP (en una terminal)

```bash
python http_server.py
# → http://127.0.0.1:8000
```

Puedes verificar las tools disponibles en:
```
GET http://127.0.0.1:8000/tools
```

### 2. Servidor MCP (lo gestiona el cliente)

El servidor MCP se lanza automáticamente por el cliente MCP vía stdio.  
Configúralo en `~/.claude.json` (Claude Code):

```json
{
  "mcpServers": {
    "http-bridge": {
      "command": "python",
      "args": ["/ruta/absoluta/a/mcp_server.py"]
    }
  }
}
```

---

## Añadir tus propias tools

Solo tienes que modificar `http_server.py`:

1. Añade un dict a la lista `TOOLS` con `name`, `description` e `inputSchema`.
2. Añade una función `run_mi_tool(args)` con la lógica.
3. Registra la función en `TOOL_HANDLERS`.

El servidor MCP las detectará automáticamente sin cambios.

```python
# Ejemplo en http_server.py

TOOLS.append({
    "name": "reverse_text",
    "description": "Invierte un texto.",
    "inputSchema": {
        "type": "object",
        "properties": {
            "text": {"type": "string"}
        },
        "required": ["text"]
    }
})

def run_reverse_text(args):
    return {"result": args["text"][::-1]}

TOOL_HANDLERS["reverse_text"] = run_reverse_text
```

---

## Contrato HTTP

| Método | Ruta              | Descripción                                |
|--------|-------------------|--------------------------------------------|
| GET    | `/tools`          | Lista todas las tools disponibles          |
| POST   | `/tools/{name}`   | Ejecuta la tool `name` con el body JSON    |

**Respuesta de `/tools`:**
```json
{
  "tools": [
    {
      "name": "calculator",
      "description": "...",
      "inputSchema": { ... }
    }
  ]
}
```

**Respuesta de `/tools/{name}`:**
```json
{ "result": { ... } }
```

---

## Estructura de archivos

```
.
├── http_server.py   # Backend HTTP con las tools
├── mcp_server.py    # Servidor MCP local (stdio)
└── README.md
```

# Para inspeccionar el servidor mcp
npx @modelcontextprotocol/inspector python C:\\Users\\acamp\\Documents\\SynologyDrive\\mcp-http-server\\mcp_server.py
npx @modelcontextprotocol/inspector python /home/chrzrd/SynologyDrive/mcp-testaserver-http/mcp_server.py
ibm-watsonx-data-integration 1.1.0
A Python SDK for watsonx.data integration.
Requires Python: >=3.10

Welcome to ibm-watsonx-data-integration

`ibm-watsonx-data-integration` is a Python SDK that enables developers and data engineers to programmatically interact with the watsonx.data integration service, IBM's next-generation data integration platform built to support modern, hybrid-cloud data pipelines.
With this SDK, users can automate and manage Flow lifecycles such as creating, configuring, starting, stopping, and monitoring Flows directly in code.

Package documentation
=====================

Full documentation is available at:
`https://ibm.github.io/ibm-watsonx-data-integration-sdk <https://ibm.github.io/ibm-watsonx-data-integration-sdk>`_
railtracks-cli 1.2.2
railtracks - A Python development server with JSON API
Requires Python: >=3.10

# Railtracks CLI

[![PyPI version](https://img.shields.io/pypi/v/railtracks-cli)](https://github.com/RailtownAI/railtracks/releases)
[![Python Versions](https://img.shields.io/pypi/pyversions/railtracks-cli?logo=python&)](https://pypi.org/project/railtracks/)
[![License](https://img.shields.io/pypi/l/railtracks-cli)](https://opensource.org/licenses/MIT)
[![PyPI - Downloads](https://img.shields.io/pepy/dt/railtracks-cli)](https://pypistats.org/packages/railtracks-cli)
[![Docs](https://img.shields.io/badge/docs-latest-00BFFF.svg?logo=)](https://railtownai.github.io/railtracks/)
[![GitHub stars](https://img.shields.io/github/stars/RailtownAI/railtracks.svg?style=social&label=Star)](https://github.com/RailtownAI/railtracks)
[![Discord](https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white)](https://discord.gg/h5ZcahDc)

A simple CLI to help developers visualize and debug their agents.

## What is Railtracks CLI?

Railtracks CLI is a development tool that provides:

- **Local Development Server**: A web-based visualizer for your railtracks projects
- **JSON API**: RESTful endpoints to interact with your project data
- **Modern UI**: A downloadable frontend interface for project visualization

## Quick Start

### 1. Installation

```bash
pip install railtracks-cli
```

### 2. Initialize Your Project

First, initialize the railtracks environment in your project directory:

```bash
railtracks init
```

This command will:

- Create a `.railtracks` directory in your project
- Add `.railtracks` to your `.gitignore` file
- Download and extract the latest frontend UI

### 3. Start the Development Server

```bash
railtracks viz
```

This starts the development server at `http://localhost:3030` with:

- API endpoints for data access
- Portable Web-based visualizer interface that can be opened in any web environment (web, mobile, vs extension, chrome extension, etc)

## Project Structure

After initialization, your project will have this structure:

```
your-project/
├── .railtracks/          # Railtracks working directory
│   ├── ui/              # Frontend interface files
│   └── *.json           # Your project JSON files
├── .gitignore           # Updated to exclude .railtracks
└── your-source-files/   # Your actual project files
```
nagiosplugin-stubs 0.7.0
Type stubs for the nagiosplugin package.
Requires Python: <4,>=3.8

.. image:: http://img.shields.io/pypi/v/nagiosplugin-stubs.svg
    :target: https://pypi.org/project/nagiosplugin-stubs
    :alt: This package on the Python Package Index

.. image:: https://github.com/Josef-Friedrich/nagiosplugin-stubs/actions/workflows/tests.yml/badge.svg
    :target: https://github.com/Josef-Friedrich/nagiosplugin-stubs/actions/workflows/tests.yml
    :alt: Tests

nagiosplugin-stubs
==================

Type stubs for the `nagiosplugin <https://github.com/mpounsett/nagiosplugin>`_ package.

Other stub packages

* https://github.com/lxml/lxml-stubs
* https://github.com/tk0miya/docutils-stubs
niftyregw 0.1.3
Thin wrapper of NiftyReg with Python and CLI interfaces.
Requires Python: >=3.10

# `niftyregw`

Pythonic wrapper for [NiftyReg](https://github.com/KCL-BMEIS/niftyreg), providing
a modern CLI and Python API for medical image registration.

NiftyReg is a suite of tools for efficient medical image registration, developed
at [King's College London](https://www.kcl.ac.uk/).

## Installation

```shell
pip install niftyregw
```

Or with [`uv`](https://docs.astral.sh/uv/):

```shell
uv pip install niftyregw
```

## CLI

```shell
niftyregw --help
```

### Affine registration

```shell
niftyregw aladin \
  --reference ref.nii.gz \
  --floating flo.nii.gz \
  --output-affine affine.txt \
  --output-result result.nii.gz
```

### Non-rigid registration

```shell
niftyregw f3d \
  --reference ref.nii.gz \
  --floating flo.nii.gz \
  --input-affine affine.txt \
  --output-cpp cpp.nii.gz \
  --output-result result.nii.gz
```

### All subcommands

| Subcommand  | Description                                          |
|-------------|------------------------------------------------------|
| `install`   | Download and install NiftyReg binaries               |
| `aladin`    | Block-matching global (affine/rigid) registration    |
| `f3d`       | Fast Free-Form Deformation non-rigid registration    |
| `measure`   | Compute similarity measures between images           |
| `jacobian`  | Compute Jacobian-based maps from transformations     |
| `resample`  | Resample an image with a given transformation        |
| `tools`     | Image manipulation tools                             |
| `average`   | Average images or transformations                    |
| `transform` | Manipulate and compose transformations               |

## Python

```python
from niftyregw import reg_aladin

reg_aladin(
    reference="ref.nii.gz",
    floating="flo.nii.gz",
    output_affine="affine.txt",
    output_result="result.nii.gz",
    rigid_only=True,
)
```

For any binary, use the generic `run` function:

```python
from niftyregw import run

run("reg_f3d", "-ref", "ref.nii.gz", "-flo", "flo.nii.gz")
```
rememble 0.1.3
Local MCP memory server with hybrid search, knowledge graph, and RAG
Requires Python: >=3.11

# Rememble

Local-first memory server with hybrid search, knowledge graph, and RAG context assembly.

SQLite + sqlite-vec + FTS5 backend. Works with any MCP client.

## Features

- Hybrid search: BM25 + vector KNN + temporal scoring (RRF fusion)
- Knowledge graph: entities, observations, relations
- Token-budgeted RAG context assembly
- Multiple embedding providers: Ollama, local (sentence-transformers), OpenAI-compat

## Install

```bash
uv tool install rememble
```

Upgrade:

```bash
uv tool upgrade rememble
```

## MCP Client Setup

### Claude Code / Claude Desktop

```json
{
  "mcpServers": {
    "rememble": {
      "command": "rememble"
    }
  }
}
```

## Configuration

Config file: `~/.rememble/config.json` (auto-created on first run).

All fields can be overridden via env vars with `REMEMBLE_` prefix and `__` as nested delimiter.

| Env var | Default | Description |
|---------|---------|-------------|
| `REMEMBLE_DB_PATH` | `~/.rememble/memory.db` | SQLite database path |
| `REMEMBLE_EMBEDDING__PROVIDER` | `ollama` | `ollama` \| `local` \| `compat` |
| `REMEMBLE_EMBEDDING__MODEL` | `nomic-embed-text` | Model name for active provider |
| `REMEMBLE_EMBEDDING__DIMENSIONS` | `768` | Embedding dimensions |
| `REMEMBLE_EMBEDDING__OLLAMA_URL` | `http://localhost:11434` | Ollama base URL |
| `REMEMBLE_EMBEDDING__API_TYPE` | `openrouter` | Label for compat provider (logging only) |
| `REMEMBLE_EMBEDDING__API_ENDPOINT` | `https://openrouter.ai/api/v1` | OpenAI-compat base URL |
| `REMEMBLE_EMBEDDING__API_KEY` | — | API key (or set `OPENROUTER_API_KEY` / `OPENAI_API_KEY`) |

## Embedding Providers

### Ollama (default)
```json
{ "embedding": { "provider": "ollama", "model": "nomic-embed-text", "dimensions": 768 } }
```

### Local (sentence-transformers, no network)
```bash
uv sync --extra local
```
```json
{ "embedding": { "provider": "local" } }
```

### OpenAI-compat (OpenRouter, OpenAI, Cohere compat, etc.)

**OpenRouter:**
```json
{
  "embedding": {
    "provider": "compat",
    "api_type": "openrouter",
    "api_endpoint": "https://openrouter.ai/api/v1",
    "model": "openai/text-embedding-3-small",
    "dimensions": 1536
  }
}
```

**Cohere via OpenAI compat API:**
```json
{
  "embedding": {
    "provider": "compat",
    "api_type": "cohere",
    "api_endpoint": "https://api.cohere.com/compatibility/v1",
    "model": "embed-english-light-v3.0",
    "dimensions": 384
  }
}
```

Set `REMEMBLE_EMBEDDING__API_KEY` or `OPENROUTER_API_KEY` / `OPENAI_API_KEY` env var.

## Development

```bash
make dev      # install deps
make test     # run tests
make check    # fmt + lint + test
```
rubin-nublado-client 12.0.1
Client for JupyterHub/JupyterLab in the Rubin Science Platform context
Requires Python: >=3.13
Keywords: rubin, lsst

# rubin-nublado-client

rubin-nublado-client is a client for JupyterHub/JupyterLab within the
Rubin Science Platform (RSP).
chromadb-client 1.5.1
Chroma Client.
Requires Python: >=3.9

<p align="center">
  <a href="https://trychroma.com"><img src="https://user-images.githubusercontent.com/891664/227103090-6624bf7d-9524-4e05-9d2c-c28d5d451481.png" alt="Chroma logo"></a>
</p>

<p align="center">
    <b>Chroma - the open-source embedding database</b>. <br />
    This package is for the Python HTTP client-only library for Chroma. This client connects to the Chroma Server. If that it not what you are looking for, you might want to check out the <a href="https://github.com/chroma-core/chroma ">full library</a>.
</p>


```bash
pip install chromadb-client # python http-client only library
```

To connect to your server and perform operations using the client only library, you can do the following:

```python
import chromadb
# Example setup of the client to connect to your chroma server
client = chromadb.HttpClient(host="localhost", port=8000)

collection = client.create_collection("all-my-documents")

collection.add(
    documents=["This is document1", "This is document2"],
    metadatas=[{"source": "notion"}, {"source": "google-docs"}], # filter on these!
    ids=["doc1", "doc2"], # unique for each doc
    embeddings = [[1.2, 2.1, ...], [1.2, 2.1, ...]]
)

results = collection.query(
    query_texts=["This is a query document"],
    n_results=2,
    # where={"metadata_field": "is_equal_to_this"}, # optional filter
    # where_document={"$contains":"search_string"}  # optional filter
)
```
## License

[Apache 2.0](./LICENSE)