semvec/pypi-packages huggingface dataset:
iflow-mcp_zivshek-rag-mcp 0.1.0
Add your description here
Requires Python: >=3.11

# Godot RAG MCP

A Model Context Protocol (MCP) tool that retrieves relevant information about Godot game engine from a local ChromaDB database.

Although this tool is for Godot in particular, but with small changes to the tool description, it can be used for any chroma database.

## Usage

- Get the chroma_db vector store ready using the [web2embeddings](https://github.com/zivshek/web2embeddings) tool.
- Download or clone this repository to your local disk.
- Configure the MCP server in VSCode Insiders (see below config instructions).

## Configuration with Visual Studio Code Insiders

**_NOTE:_** You may need to download [**Visual Studio Code Insiders**](https://code.visualstudio.com/insiders/) version to use MCP or Agent mode.

The system is configured through `settings.json`:

```json
"mcp": {
    "inputs": [],
    "servers": {
        "godot_rag": { // or whatever name you want
            "command": "cmd", // replace this with "uv" on Mac or Linux
            "args": [
                "/c", // remove this on Mac or Linux
                "uv", // remove this on Mac or Linux
                "run",
                "path to the server script 'server.py'", // C:\\dev\\rag-mcp\\server.py
                "-d",
                "path to the chroma_db on your computer", // C:\\dev\\web2embeddings\\artifacts\\vector_stores\\chroma_db
                "-c",
                "name of the collection in the chroma_db" // godotengine_chunks_SZ_400_O_20_all-MiniLM-L6-v2
            ]
        }
    }
}
```
architile 0.2.1
An implementation of all 11 regular and Archimedean tilings
Requires Python: >=3.11

<div align="center">

<h3 align="center">architile : create lattices with all 11 regular or uniform tilings</h3>

A small python library to generate 2D lattices based on repeating any of the 11 regular or uniform tilings.
Uniform tilings are arrangements of regular polygons that cover a plane without
gaps or overlaps, where each vertex has the same arrangement of polygons.

</div>

## Features

- Get **nodes** and **connectivity** for any of the 11 regular or uniform tilings
- Tile into any rectangular area with options for the boundary (cut, cut
  exactly to bounding box, or fill with partial tiles along the boundary)
- Rotate the tiling pattern by any angle

## All 11 regular or uniform tilings

![architile preview](./examples/tilings.webp)

## Installation

Install from pypi:

```bash
pip install architile
```

or using `uv` instead:

```bash
uv add architile
```

## Getting started

```py
from architile import tiling, tile_into_rectangle

# Create a SnubSquare tiling
tile = tiling.SnubSquare(a=1.0)

# Tile it into a rectangle of width 5 and height 3 (origin at (0,0))
nodes, edges = tile_into_rectangle((0.0, 0.0, 5.0, 3.0), tile)

# Tile it into a rectangle and add edges along the boundary of the rectangle
# tiling with partial tiles along the bounding box
nodes, edges = tile_into_rectangle((0.0, 0.0, 5.0, 3.0), tile, boundary="cut_fill")

# tile it into a rectangle but put the pattern at an angle of 15 degrees
nodes, edges = tile_into_rectangle((0.0, 0.0, 5.0, 3.0), tile, theta=np.pi/12)
```

## Disclaimer

This is a research project, and the code is provided "as is" without warranty of any kind. Use at your own risk.

---

Consider starring the repo if you find it useful⭐
pyami-3forge 0.2.0
Python package for accessing 3forge AMI databases
Requires Python: >=3.14

# pyami

Python package for accessing 3forge AMI databases.

This repository contains a few different “layers” you can use depending on how you like to work:

- `pyami.db.pycami`: compiled nanobind extension (fastest; lowest overhead). See the C++ implementation notes in `src/pyami/cpp/README.md`.
- `pyami.db.ami_dbapi`: DB-API style interface.
- `pyami.db.sqlalchemy_ami`: SQLAlchemy dialect. See `src/pyami/db/sqlalchemy_ami/README.md`.
- `pyami.rt.pycami_client`: compiled nanobind extension implementing 3forge AMI real-time messaging client. See `src/pyami/cpp/pycami_client_user_guide.md` and `src/pyami/cpp/pycami_client_api_reference.md`
dymo-sdk 1.6.0
A package that interacts with DYMO Printers.

# Getting Started

## Installation
To use the SDK you will need a .NET Desktop Runtime, which can be downloaded here: <https://dotnet.microsoft.com/en-us/download/dotnet/8.0>. You should also install DYMO Connect which should install any drivers you need and allow you to design the label files necessary, although DYMO Connect is not strictly necessary. DYMO Connect can be downloaded here: <https://www.dymo.com/support?cfid=user-guide>. 
```{warning} 
Note that currently for MacOS only arm chips are supported. In addition, bluetooth devices may not currently be working on mac. Also, you must be running .net 8.0 for Mac.
```
  After that, you can simply run
```{code}
pip install dymo_sdk
```

## Basic Usage
The package contains two main objects DymoLabel and DymoPrinter. A basic script to print a .dymo label generated by Dymo Connect might go like:
``` python
import dymo_sdk as dsdk

#load label from file
dymo_label = dsdk.DymoLabel("/path/to/label.dymo")
#get detected printers
printers = dsdk.get_printers()
#selected first found connected printer
for p in printers:
    if p.is_connected:
        selected_printer = p
#print label
selected_printer.print_label(label)
```
More information can be found via our documentation: https://dymosoftware.github.io/DCD-SDK-Python-Sample/
balatrobot 1.4.1
API for developing Balatro bots
Requires Python: >=3.13

<div align="center">
  <h1>BalatroBot</h1>
  <p align="center">
    <a href="https://github.com/coder/balatrobot/releases">
      <img alt="GitHub release" src="https://img.shields.io/github/v/release/coder/balatrobot?include_prereleases&sort=semver&style=for-the-badge&logo=github"/>
    </a>
    <a href="https://discord.gg/TPn6FYgGPv">
      <img alt="Discord" src="https://img.shields.io/badge/discord-server?style=for-the-badge&logo=discord&logoColor=%23FFFFFF&color=%235865F2"/>
    </a>
  </p>
  <div><img src="./docs/assets/balatrobot.svg" alt="balatrobot" width="170" height="170"></div>
  <p><em>API for developing Balatro bots</em></p>
</div>

---

BalatroBot is a mod for Balatro that serves a JSON-RPC 2.0 HTTP API, exposing game state and controls for external program interaction. The API provides endpoints for complete game control, including card selection, shop transactions, blind selection, and state management. External clients connect via HTTP POST to execute game actions programmatically.

## 📚 Documentation

https://coder.github.io/balatrobot/

## 🚀 Related Projects

- [**BalatroBot**](https://github.com/coder/balatrobot): API for developing Balatro bots
- [**BalatroLLM**](https://github.com/coder/balatrollm): Play Balatro with LLMs
- [**BalatroBench**](https://github.com/coder/balatrobench): Benchmark LLMs playing Balatro

## 🙏 Acknowledgments

This project is a fork of the original [balatrobot](https://github.com/besteon/balatrobot) repository. We would like to acknowledge and thank the original contributors who laid the foundation for this framework:

- [@phughesion](https://github.com/phughesion)
- [@besteon](https://github.com/besteon)
- [@giewev](https://github.com/giewev)

The original repository provided the initial API and botting framework that this project has evolved from. We appreciate their work in creating the foundation for Balatro bot development.
CosmicOS 1.0.0
A operating system made with python.
Requires Python: >=3.6

This is a operating system made with Python.
"How is it made?"
It was made in Feburary 12, 2026.
"How can it break after entering shutdown?"
It can say "Shutting down CosmicOS." And "Goodbye!" And Then Breaks.
## Installation
```bash
pip install CosmicOS
```
## Usage
```python
import CosmicOS

CosmicOS.cosmic()
```