semvec/pypi-packages huggingface dataset:
raglab-easygenius 0.1.0
A modular RAG library with embeddings and vector store support
License: MIT
Requires Python: >=3.7

# 🧠 MyRAGProject

**Now with interactive setup!**

- On first use, you'll be prompted to choose your embedding model (HuggingFace or Gemini) and vector database (Qdrant or FAISS).
- The setup wizard will create a `.env` file for your configuration and install only the dependencies you need.
- Supports Gemini API key and Qdrant port via `.env`.

---

## 📦 Features

- 🔍 Smart chunking of input documents
- 🤖 Embedding generation via HuggingFace
- 🧠 Vector storage using Qdrant
- 💬 Ready for question-answering and search
- 🚀 Modular and easy to extend

---

## 🗂️ Folder Structure

myragproject/
├── main.py
├── data/
│ └── sample.txt
├── app/
│ ├── config.py
│ └── ingest.py
├── raglib/
│ ├── chunking/
│ │ └── smart_chunker.py
│ ├── embeddings/
│ │ └── huggingface.py
│ └── vector_stores/
│ └── qdrant_store.py

yaml
Copy
Edit

---

## 🔧 Setup Instructions

### 1. Clone the repository

```bash
git clone https://github.com/your-username/myragproject.git
cd myragproject
2. Install dependencies
bash
Copy
Edit
pip install -r requirements.txt
Or manually install:

bash
Copy
Edit
pip install sentence-transformers qdrant-client requests
3. Start Qdrant (vector DB)
bash
Copy
Edit
docker run -p 6333:6333 -v qdrant_data:/qdrant/storage qdrant/qdrant
This ensures persistent vector storage.

4. Add your document
Place a .txt file inside the data/ folder, e.g.:

bash
Copy
Edit
data/sample.txt
🚀 Run the RAG Ingest Pipeline
bash
Copy
Edit
python main.py
It will:

Read the file

Split it into chunks

Generate embeddings

Store in Qdrant with payloads

📖 Example Output
bash
Copy
Edit
📄 Starting ingestion for: data/sample.txt
🧩 Created 4 chunks
🔢 Generated embeddings
✅ Stored 4 points in Qdrant.
✅ Embeddings stored successfully in Qdrant.
🔍 Coming Soon
❓ Ask questions and retrieve top relevant chunks

📚 Support for PDFs and multiple file types

🧪 FastAPI-based chatbot API

🧠 Tech Stack
Python 3.10+

HuggingFace (sentence-transformers)

Qdrant vector store

Docker (for Qdrant server)

🧩 Credits
Built with ❤️ by [Abhishek]

Inspired by modern RAG systems like LangChain, LlamaIndex

📄 License
MIT License

yaml
Copy
Edit

---

## ✅ To Use It Now

Just create a `README.md` file in your root folder and paste the above content.

---

Would you like me to generate:

- `requirements.txt` for you?
- Add FastAPI interface?
- Publish this to GitHub with a badge?

Let’s make this production-ready 🚀
fusebox 0.0.1
A lightweight and Pythonic dependency injection container
License: MIT
Requires Python: <4.0,>=3.9

# Fusebox

**Fusebox** is a lightweight and Pythonic dependency injection (DI) container built for simplicity and minimalism. It allows you to easily register and resolve classes and inject dependencies into functions with automatic dependency resolution.

> ⚡️ No magic. No runtime patching. Just clean, type-safe DI.

---

## 🚀 Features

- Minimal API surface
- Automatic class registration and constructor-based dependency injection for classes using the `@component` decorator
- Function parameter injection with `@inject` decorator
- Interface-to-implementation binding
- Caches singletons automatically
- Pure Python, zero dependencies

---

## 📦 Installation

```bash
poetry add fusebox
```

## 📐 Quick Example

```python
from fusebox import Container, component

@component
class ServiceA:
  def greet(self):
    return "Hello from A"

@component
class ServiceB:
  def __init__(self, service_a: ServiceA):
    self.service_a = service_a

  def greet_with_service_a(self) -> str:
    return f"ServiceB says: {self.service_a.greet()}"

service_b = Container.get(ServiceB)
print(service_b.greet_with_service_a())  # ServiceB says: Hello from A
```

## 🔁 Interface Binding

Bind an abstract base class (ABC) to a concrete implementation:

```python
from abc import ABC, abstractmethod
from fusebox import component, Container

class Greeter(ABC):
    @abstractmethod
    def greet(self): pass

@component
class HelloGreeter(Greeter):
    def greet(self):
        return "Hello!"

greeter = Container.get(Greeter)
print(greeter.greet())  # Hello!
```

## 🪄 Function Injection with `@inject`

You can also inject dependencies directly into functions using the `@inject` decorator:

```python
from fusebox import component, inject, Container

@component
class ServiceA:
    def greet(self):
        return "Hello from A"

@inject
def greet_with_a(a: ServiceA):
    return a.greet()

print(greet_with_a())  # Hello from A
```

## 🔀 Mixed Injection

You can combine injected dependencies with explicit parameters:

```python
from fusebox import component, inject, Container

@component
class ServiceA:
    def greet(self):
        return "Hello from A"

@inject
def greet_with_message(a: ServiceA, message: str):
    return f"{a.greet()} - {message}"

# 'a' is injected, 'message' is passed explicitly
print(greet_with_message(message="Welcome!"))  # Hello from A - Welcome!

# You can also override injected dependencies
custom_a = ServiceA()
print(greet_with_message(a=custom_a, message="Override!"))  # Hello from A - Override!
```

## 🧾 License

MIT License. See [LICENSE][1] file.

## 🌍 Links

📦 [PyPI][2]

💻 [GitHub][3]

## 🙌 Contributing

Pull requests are welcome! Please submit issues and suggestions to help improve the project.

[1]: LICENSE
[2]: https://pypi.org/project/fusebox
[3]: https://github.com/ftbits/fusebox