semvec/pypi-packages huggingface dataset:
orange-mcp-llm-bridge 0.1.0
Bridge between MCP protocol and LLM clients
Requires Python: >=3.6

# MCP LLM Bridge

A bridge connecting Model Context Protocol (MCP) servers to OpenAI-compatible LLMs. Primary support for OpenAI API, with additional compatibility for local endpoints that implement the OpenAI API specification.

The implementation provides a bidirectional protocol translation layer between MCP and OpenAI's function-calling interface. It converts MCP tool specifications into OpenAI function schemas and handles the mapping of function invocations back to MCP tool executions. This enables any OpenAI-compatible language model to leverage MCP-compliant tools through a standardized interface, whether using cloud-based models or local implementations like Ollama.

Read more about MCP by Anthropic here:

- [Resources](https://modelcontextprotocol.io/docs/concepts/resources)
- [Prompts](https://modelcontextprotocol.io/docs/concepts/prompts)
- [Tools](https://modelcontextprotocol.io/docs/concepts/tools)
- [Sampling](https://modelcontextprotocol.io/docs/concepts/sampling)

Demo:

![MCP LLM Bridge Demo](assets/output.gif)

## Quick Start

```bash
# Install
curl -LsSf https://astral.sh/uv/install.sh | sh
git clone https://github.com/bartolli/mcp-llm-bridge.git
cd mcp-llm-bridge
uv venv
source .venv/bin/activate
uv pip install -e .

# Create test database
python -m mcp_llm_bridge.create_test_db
```

## Configuration

### OpenAI (Primary)

Create `.env`:

```bash
OPENAI_API_KEY=your_key
OPENAI_MODEL=gpt-4o # or any other OpenAI model that supports tools
```

Note: reactivate the environment if needed to use the keys in `.env`: `source .venv/bin/activate`

Then configure the bridge in [src/mcp_llm_bridge/main.py](src/mcp_llm_bridge/main.py)

```python
config = BridgeConfig(
    mcp_server_params=StdioServerParameters(
        command="uvx",
        args=["mcp-server-sqlite", "--db-path", "test.db"],
        env=None
    ),
    llm_config=LLMConfig(
        api_key=os.getenv("OPENAI_API_KEY"),
        model=os.getenv("OPENAI_MODEL", "gpt-4o"),
        base_url=None
    )
)
```

### Additional Endpoint Support

The bridge also works with any endpoint implementing the OpenAI API specification:

#### Ollama

```python
llm_config=LLMConfig(
    api_key="not-needed",
    model="mistral-nemo:12b-instruct-2407-q8_0",
    base_url="http://localhost:11434/v1"
)
```

Note: After testing various models, including `llama3.2:3b-instruct-fp16`, I found that `mistral-nemo:12b-instruct-2407-q8_0` handles complex queries more effectively.

#### LM Studio

```python
llm_config=LLMConfig(
    api_key="not-needed",
    model="local-model",
    base_url="http://localhost:1234/v1"
)
```

I didn't test this, but it should work.

## Usage

```bash
python -m mcp_llm_bridge.main

# Try: "What are the most expensive products in the database?"
# Exit with 'quit' or Ctrl+C
```

## Running Tests

Install the package with test dependencies:

```bash
uv pip install -e ".[test]"
```

Then run the tests:

```bash
python -m pytest -v tests/
```
## License

[MIT](LICENSE.md)

## Contributing

PRs welcome.
orange-mcp-multilspy 0.1.0
MCP server that exposes Language Server Protocol functionality via multilspy
Requires Python: >=3.12

# MCP-MultilspyLSP

An MCP server that exposes Language Server Protocol (LSP) capabilities through multilspy.

## What is this?

This project provides an [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server that
gives language models access to language intelligence features from the Language Server Protocol (LSP).
It uses [multilspy](https://github.com/microsoft/multilspy), a Python library that simplifies
interfacing with various language servers.

## Features

- **Language Intelligence**: Get code completions, find definitions, references, and more
- **Multi-language Support**: Works with multiple programming languages including Python, Java, TypeScript, and more
- **Easy Integration**: Works with any MCP-compatible client like Claude Desktop
- **Static Analysis**: Leverage the power of language servers for code understanding

## Installation

```bash
pip install mcp-multilspy
```

## Usage

Start the server directly:

```bash
mcp-multilspy
```

Or install it in Claude Desktop:

```bash
mcp install mcp-multilspy
```

## Supported Languages

- Java (Eclipse JDTLS)
- Python (jedi-language-server)
- Rust (Rust Analyzer)
- C# (OmniSharp/RazorSharp)
- TypeScript (TypeScriptLanguageServer)
- JavaScript (TypeScriptLanguageServer)
- Go (gopls)
- Dart (Dart Language Server)
- Ruby (Solargraph)

## Example

Here's how to use this server with an MCP client:

```python
# Initialize a TypeScript language server session
session = await initialize_language_server(
    session_id="ts-session", 
    project_root="/path/to/project",
    language="typescript"
)

# Find where a symbol is defined
definitions = await request_definition(
    session_id="ts-session",
    file_path="src/index.ts",
    line=10,  # 0-indexed
    column=15  # 0-indexed
)

# Find all references to a symbol
references = await request_references(
    session_id="ts-session",
    file_path="src/index.ts",
    line=10,
    column=15
)

# Get code completion suggestions
completions = await request_completions(
    session_id="ts-session",
    file_path="src/index.ts", 
    line=10,
    column=15
)

# Get hover information
hover_info = await request_hover(
    session_id="ts-session",
    file_path="src/index.ts",
    line=10,
    column=15
)

# Get document symbols
symbols = await request_document_symbols(
    session_id="ts-session",
    file_path="src/index.ts"
)

# Clean up when done
await shutdown_language_server(session_id="ts-session")
```

## Requirements

- Python 3.12 or higher
- Language-specific requirements:
  - For Java: JDK 17.0.6 or higher
  - For JavaScript/TypeScript: Node.js v18.16.0 or higher

## License

MIT
orange-fibery-mcp-server 0.1.0
Add your description here
Requires Python: >=3.10

# Fibery MCP Server

This MCP (Model Context Protocol) server provides integration between Fibery and any LLM provider supporting the MCP protocol (e.g., Claude for Desktop), allowing you to interact with your Fibery workspace using natural language.

## ✨ Features
- Query Fibery entities using natural language
- Get information about your Fibery databases and their fields
- Create and update Fibery entities through conversational interfaces

## 📦 Installation

### Prerequisites

- A Fibery account with an API token
- Python 3.10 or higher
- [uv](https://github.com/astral-sh/uv)

```bash
uv tool install fibery-mcp-server
```

## 🔌 MCP Integration
Add this configuration to your MCP client config file. 

In Claude Desktop, you can access the config in **Settings → Developer → Edit Config**:
```json
{
    "mcpServers": {
        "fibery-mcp-server": {
            "command": "uv",
            "args": [
                 "tool",
                 "run",
                 "fibery-mcp-server",
                 "--fibery-host",
                 "your-domain.fibery.io",
                 "--fibery-api-token",
                 "your-api-token"
            ]
        }
    }
}
```
Note: If "uv" command does not work, try absolute path (i.e. /Users/username/.local/bin/uv)

**For Development:**

```json
{
    "mcpServers": {
        "arxiv-mcp-server": {
            "command": "uv",
            "args": [
                "--directory",
                "path/to/cloned/fibery-mcp-server",
                "run",
                "fibery-mcp-server",
                "--fibery-host",
                 "your-domain.fibery.io",
                 "--fibery-api-token",
                 "your-api-token"
            ]
        }
    }
}
```

## 🚀 Available Tools

#### 1. List Databases (`list_databases`)

Retrieves a list of all databases available in your Fibery workspace.

#### 2. Describe Database (`describe_database`)

Provides a detailed breakdown of a specific database's structure, showing all fields with their titles, names, and types.

#### 3. Query Database (`query_database`)

Offers powerful, flexible access to your Fibery data through the Fibery API.

#### 4. Create Entity (`create_entity`)

Creates new entities in your Fibery workspace with specified field values.

#### 5. Update Entity (`update_entity`) 

Updates existing entities in your Fibery workspace with new field values.
orange-artemis-mcp 0.1.6
Artemis MCP Server to Connect with Artemis API and Create ART Formulas
Requires Python: >=3.6
Keywords: artemis, mcp, crypto, stablecoins, digital finance

## artemis-mcp

```
     _    ____ _____ _____ __  __ ___ ____    __  __  ____ ____
    / \  |  _ \_   _| ____|  \/  |_ _/ ___|  |  \/  |/ ___|  _ \
   / _ \ | |_) || | |  _| | |\/| || |\___ \  | |\/| | |   | |_) |
  / ___ \|  _ < | | | |___| |  | || | ___) | | |  | | |___|  __/
 /_/   \_\_| \_\|_| |_____|_|  |_|___|____/  |_|  |_|\____|_|
```

## Prerequisites

- Python 3.11+
- [uv](https://docs.astral.sh/uv/getting-started/installation/#installation-methods). On MacOS, you can install it using Homebrew: `brew install uv`.
- Claude Desktop
- Artemis API Key
- Artemis Snowflake Login

## Installation

### Automated Using OpenTools (Easier)

Install [OpenTools](https://opentools.com/docs/quickstart) prerequisites.

Then run:

```bash
npx opentools@latest i artemis
```

### Manual Setup (More Work)

- Install uv

Copy `sample_claude_desktop_config.json` to your `claude_desktop_config.json` file:

- On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
- On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

Fill out the relevant fields in `claude_desktop_config.json`:

- `<UV_PATH>` - Path to uv executable (run `where python` on MacOS)
- `<PATH_TO_ARTEMIS_MCP_REPO>` - Path to local clone of the Artemis MCP repo
- `<ARTEMIS_API_KEY>` - Your Artemis API Key

- Restart Claude Desktop
- Artemis MCP Tools should now be available!

## Available Tools

The Artemis MCP server provides the following tools:

### API Tools
- `validate-artemis-api-key`: Creates and validates connection to Artemis API
- `get-artemis-data`: Retrieves data from Artemis API for given crypto token symbols and metrics
- `get-artemis-supported-metrics-for-symbol`: Retrieves supported metrics for a given crypto token symbol

### Formula Generation Tools
- `generate-art-formula`: Generates an ART formula for retrieving crypto prices, fees, revenue, and other time-series data
- `generate-artinfo-formula`: Generates an ARTINFO formula for asset classifications, available metrics, market cap rankings, and metadata
aman-llm 0.1.6
Easy-to-use LLM interface to automate file and shell operations.
Requires Python: >=3.8

# aman_llm

**`aman_llm`** is a simple Python package that enables AI-powered file and shell operations using Google's Gemini API. It uses agent-based logic to interpret natural language instructions and perform system-level tasks like creating files, navigating directories, and more — all powered by LLMs.

---

## 🚀 Installation

```bash
pip install aman_llm
```

---

## 🔐 Environment Setup

To use `aman_llm`, you must provide a Gemini API key.

### Step 1: Get Your Gemini API Key

Visit the following URL and generate your API key:

👉 [https://aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey)

### Step 2: Create a `.env` File

In your project root, create a `.env` file and add the following:

```env
GOOGLE_API_KEY=your-gemini-api-key-here
```

This key will be used to authenticate with Gemini when calling the LLM.

---

## ✅ Example Usage

```python
from aman_llm import llm_call

llm_call("Create a file named 'integer.txt' and write numbers 1 to 10 in it", stream=True)
```

---

## 📂 Features

- ✅ Create and modify text files using AI
- ✅ Run shell commands like `ls`, `pwd`, `mkdir`, etc.
- ✅ Delegate tasks between intelligent agents (File & Shell)
- ✅ Powered by Google's `gemini-2.0-flash` model
- ✅ Stream responses with rich markdown output

---

## ✨ Coming Soon

- [ ] More tool integrations (e.g. web scraping, PDF generation)
- [ ] Async version of the LLM interface
- [ ] LangChain-style chaining

---

## 📜 License

MIT License

---

## 👨‍💻 Created By

**Aman Prasad**  
🔗 [Connect on LinkedIn](https://www.linkedin.com/in/amanprasad/)