semvec/pypi-packages huggingface dataset:
plapi-example-api 0.0.5
A simple example package that prints Hello, World!
Requires Python: >=3.6
Keywords: example hello world package

# plapi-example

## Description
`plapi-example` is a simple Python package that provides a function to print "Hello, World!". 

## Installation
You can install the package using pip. Run the following command:

```
pip install plapi-example
```

## Usage
To use the package, you can import it in your Python code:

```python
import plapi.hello_world

plapi.hello_world.hello()
```

This will print:

```
Hello, World!
```

## Running Tests
To run the tests for this package, navigate to the `tests` directory and run:

```
pytest test_hello_world.py
```

## Contributing
Feel free to submit issues and pull requests to improve the package.
cqu 0.1.1
CQU is a Classical and Quantum Machine Learning Library that is built on top of Qiskit and PyTorch, giving easy access to both classical and quantum machine learning algorithms through simple interfaces. It is designed to be easy to use and to be easily extensible, including a Preprocessor class that allows for easy integration of new data preprocessing techniques.
Requires Python: >=3.10.0

# CQU - Classical And Quantum ML

**cqu** is a classical and quantum machine learning library that can be used to quickly and easily reap benefits of both classical and quantum machine learning algorithms!

- Example usage
```
from cqu.preprocessing import Preprocessor, MissingValueStrategies
from cqu.quantum_embedding import QuantumClassifier

pp = Preprocessor("path/to/dataset")
strategies = { 
    'v3': MissingValueStrategies.FILL_MEDIAN, 
    'time': MissingValueStrategies.FILL_NOCB, 
    'class': MissingValueStrategies.DROP_ROWS 
}
pp.clean_missing(strategies)

dataset = pp.dataframe[['v3', 'v10', 'v11', 'class']]

qc = QuantumClassifier()
qc.train(dataset, "class")

test_df = pd.DataFrame(np.random.rand(5))
prediction = qc.predict(test_df).flatten()

if prediction[0] == 1:
    print("Prediction: Fraud")
else:
    print("Prediction: Non-fraud")
```
apex-code 2.0.0
Swiss army knife personal code library
Requires Python: >=3.8

# apex_code

### Generate distribution archive
```bash
python3 -m pip install --upgrade build
```
```bash
rm dist/*
```
```bash
python3 -m build
```

### Upload the distribution archive
```bash
python3 -m pip install --upgrade twine
```
```bash
python3 -m twine upload dist/*
```

### Install
```bash
pip install apex_matrix
```

### Tests
```bash
python3 -m unittest discover -s tests
```


### Usage
```python
from apex_matrix.Matrix import Matrix

# Create matrix object
my_matrix = Matrix([1,2,3],[4,5,6])

# View docs
help(Matrix)
```
memory-mcp-server 0.1.3
MCP server implementation for managing Claude's memory and knowledge graph
Requires Python: >=3.12

# Memory MCP Server

An implementation of the Model Context Protocol (MCP) server for managing Claude's memory and knowledge graph.

## Installation

You can install the package using `uv`:

```bash
uvx memory-mcp-server
```

Or install it from the repository:

```bash
uv pip install git+https://github.com/estav/python-memory-mcp-server.git
```

## Usage

Once installed, you can run the server using:

```bash
uvx memory-mcp-server
```

### Usage

The server uses a JSONL file for storage:

```bash
# Use default memory.jsonl in package directory
memory-mcp-server

# Specify custom file location
memory-mcp-server --path /path/to/memory.jsonl

# Configure cache TTL (default: 60 seconds)
memory-mcp-server --path /path/to/memory.jsonl --cache-ttl 120
```

### Integration with Claude Desktop

To use this MCP server with Claude Desktop, add the following to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "memory": {
      "command": "uvx",
      "args": ["memory-mcp-server"],
      "env": {
        // Optional: Neo4j configuration
        "NEO4J_URI": "neo4j://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "your-password"
      }
    }
  }
}
```

## Development

1. Clone the repository:
```bash
git clone https://github.com/estav/python-memory-mcp-server.git
cd python-memory-mcp-server
```

2. Create a virtual environment and install dependencies:
```bash
uv venv
source .venv/bin/activate
uv pip install -e ".[test]"  # Include test dependencies
```

3. Run tests:
```bash
pytest                    # Run all tests
pytest -v                # Run with verbose output
pytest -v --cov         # Run with coverage report
```

4. Run the server locally:
```bash
python -m memory_mcp_server  # Run with default memory.jsonl
```

## Testing

The project uses pytest for testing. The test suite includes:

### Unit Tests
- `test_knowledge_graph_manager.py`: Tests for knowledge graph operations
- `test_server.py`: Tests for MCP server implementation
- `test_backends/`: Tests for backend implementations
  - `test_jsonl.py`: JSONL backend tests

### Running Tests
```bash
# Run all tests
pytest

# Run with coverage report
pytest --cov=memory_mcp_server

# Run specific test file
pytest tests/test_server.py

# Run tests with verbose output
pytest -v
```

### Test Fixtures
The `conftest.py` file provides common test fixtures:
- `temp_jsonl_path`: Creates a temporary JSONL file
- `knowledge_graph_manager`: Provides a KnowledgeGraphManager instance

## License

This project is licensed under the MIT License - see the LICENSE file for details.