semvec/pypi-packages huggingface dataset:
stores 0.1.8.dev3
Repository of Python functions and tools for LLMs
Requires Python: >=3.10

# stores

Repository of Python functions and tools for LLMs

## Why we built Stores

Just as tool use is often cited as a key development in human civilization, we believe that tool use represents a major transition in AI development.

**The aim of Stores is to make it super simple to build LLM Agents that use tools.**

There are two main elements:
1. A public repository of [tools](https://stores-tools.vercel.app) that anyone can contribute to
2. This Python library that handles tool installation and formatting

For more details, check out the [documentation](https://stores-tools.vercel.app/docs).

## Design principles

- **Open-source**: Each set of tools in the Stores collection is a public git repository. In the event the Stores database is no longer operational, the library and tools will still work as long as the git repositories exist.
- **Isolation**: Tools are isolated in their own virtual environments. This makes it trivial to manage tools with conflicting dependencies and reduces unnecessary access to sensitive environment variables.
- **Framework compatibility**: In order to pass information about tools, LLM providers often require different formats that can make it cumbersome to switch between providers. Stores makes it easy to output the required formats across providers.

## Usage

```sh
pip install stores
```

Or if you are using `uv`:

```sh
uv add stores
```

Then load one of the available indexes and use it with your favorite LLM package.

```python {6, 11}
import anthropic
import stores

client = anthropic.Anthropic()

index = stores.Index(["silanthro/hackernews"])

response = client.messages.create(
    model=model,
    messages=messages,
    tools=index.format_tools("anthropic"),
)
```
mssql-py-mcp 0.1.3
A MSSQL MCP server using pure Python TDS
Requires Python: >=3.10

# mssql-py-mcp

A MSSQL MCP server implementation in Python, designed to work with the `pytds` library. This project provides a simple and efficient way to interact with Microsoft SQL Server databases, leveraging the pure Python `pytds` driver for connectivity.

This project uses **pure `pytds`** for database connections.

## What is `pytds`?

`pytds` is a pure Python implementation of the Tabular Data Stream (TDS) protocol, which is used to communicate with Microsoft SQL Server. Unlike other drivers that rely on native libraries (like FreeTDS), `pytds` is written entirely in Python, making it platform-independent and easy to install.

### Key Features of `pytds`

-   **Pure Python**: No external dependencies or compilers needed.
-   **Cross-Platform**: Runs on any platform where Python is supported.
-   **Thread-Safe**: Safe to use in multi-threaded applications.
-   **Supports various authentication methods**: Including SQL Server and Windows authentication.
-   **Lightweight**: Minimal overhead and easy to integrate.

## Features

-   **MCP Server**: Implements the Minecraft JEWEI MCP protocol for database interaction.
-   **MSSQL Connectivity**: Connects to Microsoft SQL Server using `pytds`.
-   **Database Operations**: Supports executing queries, listing tables, and retrieving database information.
-   **Easy Configuration**: Uses a `.env` file for simple setup of database credentials.

## Installation

1.  **Clone the repository**:
    ```bash
    git clone https://github.com/your-username/mssql-py-mcp.git
    cd mssql-py-mcp
    ```

2.  **Create a virtual environment** (recommended):
    ```bash
    python -m venv venv
    source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
    ```

3.  **Install dependencies**:
    ```bash
    pip install -r requirements.txt
    ```

## Configuration

1.  Create a `.env` file in the root directory of the project. You can copy the example file:
    ```bash
    cp .env.example .env
    ```

2.  Edit the `.env` file with your MSSQL database credentials:
    ```
    DB_HOST=your_server_address
    DB_USER=your_username
    DB_PASSWORD=your_password
    DB_NAME=your_database_name
    DB_PORT=1433
    ```

## Usage

Run the MCP server with the following command:

```bash
python -m mssql_py_mcp.server
```

The server will start and listen for incoming MCP connections on the default port.

## How It Works

The server listens for MCP commands, establishes a connection to the MSSQL database using `pytds`, executes the requested queries, and returns the results in the MCP format. The core logic is handled in `mssql_py_mcp/core.py`, which manages the database connection and query execution.

## Contributing

Contributions are welcome! Please open an issue or submit a pull request if you have any improvements or bug fixes.

## License

This project is licensed under the MIT License. See the `LICENSE` file for more details.