vectorwave 0.2.8__tar.gz → 0.3.0__tar.gz

vectorwave-0.3.0/PKG-INFO

@@ -0,0 +1,258 @@
+Metadata-Version: 2.4
+Name: vectorwave
+Version: 0.3.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Requires-Dist: weaviate-client>=4.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: sentence-transformers
+Requires-Dist: requests
+Requires-Dist: openai
+Requires-Dist: pygithub
+Requires-Dist: schedule
+License-File: LICENSE
+License-File: NOTICE
+Summary: VectorWave: Seamless Auto-Vectorization Framework
+Author-email: junyeonggim <junyeonggim5@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/cozymori/vectorwave
+
+
+![VectorWave Logo](./docs_kr/images/vectorwave.png)
+
+Need more information? Visit [here](https://www.cozymori.net/vectorwave)
+
+# VectorWave
+![Star](https://badgen.net/github/stars/cozymori/vectorwave)
+![Release](https://badgen.net/github/release/cozymori/vectorwave)
+![Tag](https://badgen.net/github/tag/cozymori/vectorwave)
+![Commit](https://badgen.net/github/last-commit/cozymori/vectorwave)
+![Contributors](https://badgen.net/github/contributors/cozymori/vectorwave)
+![OpenPrs](https://badgen.net/github/open-prs/cozymori/vectorwave)
+![MergedPrs](https://badgen.net/github/merged-prs/cozymori/vectorwave)
+![Checks](https://badgen.net/github/checks/cozymori/vectorwave)
+![Pypi](https://badgen.net/pypi/v/vectorwave)
+<br>**Seamless Auto-Vectorization Framework**
+
+We transform volatile data that disappears the moment code is executed into a Searchable and Reusable permanent knowledge asset.
+
+### Requirements
+
+* **Python**: 3.10 ~ 3.13
+* **Docker**: Required to run the Weaviate database.
+* (Optional) **OpenAI API Key**: Required for AI auto-documentation and high-performance embedding.
+
+### How to reach us
+
+Have questions or found a bug? Please join our community.
+
+* **GitHub Issues**: [https://github.com/cozymori/vectorwave/issues](https://github.com/cozymori/vectorwave/issues)
+
+### Contributors
+[See the contributors of vectorwave](https://github.com/Cozymori/VectorWave/graphs/contributors)<br>
+VectorWave is an open-source project and we welcome your contributions.
+Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=https://github.com/cozymori/vectorwave/blob/main/CONTRIBUTING.md) in the GitHub repository.
+
+---
+
+## 🚀 What is VectorWave?
+
+**VectorWave** is a unified framework designed to solve the "Efficiency vs. Reliability" dilemma in LLM-integrated applications. It introduces a new paradigm of **Execution-Level Semantic Optimization** combined with **Autonomous Self-Healing**.
+
+Unlike conventional semantic caching tools that primarily focus on text similarity, **VectorWave** captures the entire **Function Execution Context**. It creates a permanent "Golden Dataset" from your successful executions and uses it to:
+
+1.  **Slash Costs**: Serve cached results for semantically similar inputs, bypassing expensive computations.
+2.  **Fix Bugs**: Automatically diagnose runtime errors and generate GitHub PRs using LLM.
+3.  **Monitor Quality**: Detect when user inputs start drifting away from known patterns (Semantic Drift).
+
+##  Architecture
+
+VectorWave operates as a transparent layer between your application and the LLM/Infrastructure, handling everything from vectorization to GitOps automation.
+
+![VectorWave Architecture](./docs_kr/images/module_arch.png)
+
+### Core Components
+* **Optimization Engine**: Intercepts function calls to check for semantic cache hits using HNSW indexes.
+* **Trace Context Manager**: Collects execution logs, inputs, and outputs without modifying your code structure.
+* **Self-Healing Pipeline**: An autonomous agent that wakes up on errors, diagnoses the root cause, and submits patches.
+
+## 😊 Quick Start
+
+You can attach VectorWave to any Python function using a simple decorator.
+
+### 1. Prerequisites (Start Vector DB)
+
+VectorWave requires a Vector Database (Weaviate) to store execution contexts.
+Create a `docker-compose.yml` file and start the service:
+
+```yaml
+# docker-compose.yml
+version: '3.4'
+services:
+  weaviate:
+    command:
+    - --host
+    - 0.0.0.0
+    - --port
+    - '8080'
+    - --scheme
+    - http
+    image: semitechnologies/weaviate:1.26.1
+    ports:
+    - 8080:8080
+    - 50051:50051
+    restart: on-failure:0
+    environment:
+      QUERY_DEFAULTS_LIMIT: 25
+      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
+      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
+      DEFAULT_VECTORIZER_MODULE: 'none'
+      ENABLE_MODULES: 'text2vec-openai,generative-openai'
+      CLUSTER_HOSTNAME: 'node1'
+
+```
+
+Run the container:
+
+```bash
+docker-compose up -d
+
+```
+
+### 2. Install VectorWave
+
+```bash
+pip install vectorwave
+
+```
+
+### 3. Basic Usage (Semantic Caching)
+
+Now, apply the `@vectorize` decorator to your functions.
+
+```python
+import time
+from vectorwave import vectorize, initialize_database
+
+# 1. (Optional) Set up your OpenAI Key for vectorization
+# os.environ["OPENAI_API_KEY"] = "sk-..."
+
+initialize_database()
+
+# 2. Just add the @vectorize decorator!
+@vectorize(semantic_cache=True, cache_threshold=0.95, auto=True)
+def expensive_llm_task(query: str):
+    # Simulate a slow and expensive API call
+    time.sleep(2) 
+    return f"Processed result for: {query}"
+
+# First call: Runs the function (Cache Miss) -> Took 2.0s
+print(expensive_llm_task("How do I fix a Python bug?"))
+
+# Second call: Returns from Weaviate DB (Cache Hit) -> Took 0.02s!
+# Even if the query is slightly different but semantically same.
+print(expensive_llm_task("Tell me how to debug Python code."))
+
+```
+
+### 4. Self-Healing in Action
+
+When your code breaks, VectorWave actively fixes it.
+
+```python
+# Suppose this function has a bug (ZeroDivisionError)
+@vectorize(auto=True)
+def risky_calculation(a, b):
+    return a / b
+
+# Triggering an error
+risky_calculation(10, 0) 
+
+```
+
+**What happens next?**
+
+1. **Detection**: The `AutoHealerBot` detects the `ZeroDivisionError`.
+2. **Diagnosis**: It retrieves the source code and error stack trace.
+3. **Fix**: It uses an LLM to generate a patch (adding `try-except` or input validation).
+4. **Action**: A **Pull Request** is automatically created in your GitHub repository.
+
+![VectorWave Healer Architecture](./docs_kr/images/self_healing.png)
+
+
+##  Key Features
+
+### ⚡ Optimization Engine (Semantic Caching)
+
+Don't pay for the same computation twice. VectorWave uses **Weaviate** vector database to store and retrieve function results based on meaning, not just exact string matching.
+
+* **Latency**: Reduced from seconds to milliseconds.
+* **Cost**: Up to 90% reduction in LLM token usage.
+
+![VectorWave Semantic Caching Architecture](./docs_kr/images/detail_arch.png)
+
+
+###  Self-Healing & GitOps
+
+VectorWave doesn't just log errors; it acts on them.
+
+* **Automated Root Cause Analysis (RCA)** using RAG.
+* **GitOps Integration**: Generates actual code fixes and pushes them to a new branch.
+* **Cooldown Mechanism**: Prevents spamming PRs for the same error.
+
+###  Semantic Drift Radar
+
+Detect when your users are asking things your model wasn't designed for.
+
+* **Anomaly Detection**: Calculates the distance between new queries and your "Golden Dataset".
+* **Alerting**: Sends notifications (e.g., Discord) when drift exceeds the threshold (default 0.25).
+
+![VectorWave Drift Architecture](./docs_kr/images/semantic_drift.png)
+
+
+##  How does it work?
+
+Unlike traditional Key-Value caching (e.g., Redis), VectorWave understands **Context**.
+
+1. **Vectorization**: It converts function arguments into high-dimensional vectors using OpenAI or HuggingFace models.
+2. **Search**: It performs an Approximate Nearest Neighbor (ANN) search in the vector store.
+3. **Decision**:
+* If a neighbor is found within the `threshold` -> **Return Cached Result**.
+* If not -> **Execute Function** -> **Async Log to DB**.
+
+
+
+##  Performance Benchmark
+
+| Metric | Direct Execution | With VectorWave | Improvement |
+| --- | --- | --- | --- |
+| **Latency (Hit)** | ~2.5s (LLM API) | **~0.02s** | **125x Faster** |
+| **Cost (Hit)** | $0.03 / call | **$0.00** | **100% Savings** |
+| **Reliability** | Manual Fix Required | **Auto-PR Created** | **Autonomous** |
+
+##  Feature Comparison
+
+Why choose VectorWave over traditional semantic caches?
+
+| Feature | Traditional Tools (e.g., GPTCache) | **VectorWave** |
+| :--- | :---: | :---: |
+| **Semantic Caching** | O (Text-based) | **O (Execution Context)** |
+| **Self-Healing (Auto-Fix)** | X | **O (Autonomous)** |
+| **GitOps (Auto-PR)** | X | **O (Seamless)** |
+| **Semantic Drift Detection** | X | **O (Drift Radar)** |
+| **Zero-Config Setup** | △ (Setup Required) | **O (Decorator)** |
+
+## 😍 Contributing
+
+We are extremely open to contributions! Whether it's a new vectorizer, a better healing prompt, or just a typo fix.
+Please check our [Contribution Guide](./Contributing.md).
+

vectorwave-0.3.0/Readme.md

@@ -0,0 +1,229 @@
+
+![VectorWave Logo](./docs_kr/images/vectorwave.png)
+
+Need more information? Visit [here](https://www.cozymori.net/vectorwave)
+
+# VectorWave
+![Star](https://badgen.net/github/stars/cozymori/vectorwave)
+![Release](https://badgen.net/github/release/cozymori/vectorwave)
+![Tag](https://badgen.net/github/tag/cozymori/vectorwave)
+![Commit](https://badgen.net/github/last-commit/cozymori/vectorwave)
+![Contributors](https://badgen.net/github/contributors/cozymori/vectorwave)
+![OpenPrs](https://badgen.net/github/open-prs/cozymori/vectorwave)
+![MergedPrs](https://badgen.net/github/merged-prs/cozymori/vectorwave)
+![Checks](https://badgen.net/github/checks/cozymori/vectorwave)
+![Pypi](https://badgen.net/pypi/v/vectorwave)
+<br>**Seamless Auto-Vectorization Framework**
+
+We transform volatile data that disappears the moment code is executed into a Searchable and Reusable permanent knowledge asset.
+
+### Requirements
+
+* **Python**: 3.10 ~ 3.13
+* **Docker**: Required to run the Weaviate database.
+* (Optional) **OpenAI API Key**: Required for AI auto-documentation and high-performance embedding.
+
+### How to reach us
+
+Have questions or found a bug? Please join our community.
+
+* **GitHub Issues**: [https://github.com/cozymori/vectorwave/issues](https://github.com/cozymori/vectorwave/issues)
+
+### Contributors
+[See the contributors of vectorwave](https://github.com/Cozymori/VectorWave/graphs/contributors)<br>
+VectorWave is an open-source project and we welcome your contributions.
+Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=https://github.com/cozymori/vectorwave/blob/main/CONTRIBUTING.md) in the GitHub repository.
+
+---
+
+## 🚀 What is VectorWave?
+
+**VectorWave** is a unified framework designed to solve the "Efficiency vs. Reliability" dilemma in LLM-integrated applications. It introduces a new paradigm of **Execution-Level Semantic Optimization** combined with **Autonomous Self-Healing**.
+
+Unlike conventional semantic caching tools that primarily focus on text similarity, **VectorWave** captures the entire **Function Execution Context**. It creates a permanent "Golden Dataset" from your successful executions and uses it to:
+
+1.  **Slash Costs**: Serve cached results for semantically similar inputs, bypassing expensive computations.
+2.  **Fix Bugs**: Automatically diagnose runtime errors and generate GitHub PRs using LLM.
+3.  **Monitor Quality**: Detect when user inputs start drifting away from known patterns (Semantic Drift).
+
+##  Architecture
+
+VectorWave operates as a transparent layer between your application and the LLM/Infrastructure, handling everything from vectorization to GitOps automation.
+
+![VectorWave Architecture](./docs_kr/images/module_arch.png)
+
+### Core Components
+* **Optimization Engine**: Intercepts function calls to check for semantic cache hits using HNSW indexes.
+* **Trace Context Manager**: Collects execution logs, inputs, and outputs without modifying your code structure.
+* **Self-Healing Pipeline**: An autonomous agent that wakes up on errors, diagnoses the root cause, and submits patches.
+
+## 😊 Quick Start
+
+You can attach VectorWave to any Python function using a simple decorator.
+
+### 1. Prerequisites (Start Vector DB)
+
+VectorWave requires a Vector Database (Weaviate) to store execution contexts.
+Create a `docker-compose.yml` file and start the service:
+
+```yaml
+# docker-compose.yml
+version: '3.4'
+services:
+  weaviate:
+    command:
+    - --host
+    - 0.0.0.0
+    - --port
+    - '8080'
+    - --scheme
+    - http
+    image: semitechnologies/weaviate:1.26.1
+    ports:
+    - 8080:8080
+    - 50051:50051
+    restart: on-failure:0
+    environment:
+      QUERY_DEFAULTS_LIMIT: 25
+      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
+      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
+      DEFAULT_VECTORIZER_MODULE: 'none'
+      ENABLE_MODULES: 'text2vec-openai,generative-openai'
+      CLUSTER_HOSTNAME: 'node1'
+
+```
+
+Run the container:
+
+```bash
+docker-compose up -d
+
+```
+
+### 2. Install VectorWave
+
+```bash
+pip install vectorwave
+
+```
+
+### 3. Basic Usage (Semantic Caching)
+
+Now, apply the `@vectorize` decorator to your functions.
+
+```python
+import time
+from vectorwave import vectorize, initialize_database
+
+# 1. (Optional) Set up your OpenAI Key for vectorization
+# os.environ["OPENAI_API_KEY"] = "sk-..."
+
+initialize_database()
+
+# 2. Just add the @vectorize decorator!
+@vectorize(semantic_cache=True, cache_threshold=0.95, auto=True)
+def expensive_llm_task(query: str):
+    # Simulate a slow and expensive API call
+    time.sleep(2) 
+    return f"Processed result for: {query}"
+
+# First call: Runs the function (Cache Miss) -> Took 2.0s
+print(expensive_llm_task("How do I fix a Python bug?"))
+
+# Second call: Returns from Weaviate DB (Cache Hit) -> Took 0.02s!
+# Even if the query is slightly different but semantically same.
+print(expensive_llm_task("Tell me how to debug Python code."))
+
+```
+
+### 4. Self-Healing in Action
+
+When your code breaks, VectorWave actively fixes it.
+
+```python
+# Suppose this function has a bug (ZeroDivisionError)
+@vectorize(auto=True)
+def risky_calculation(a, b):
+    return a / b
+
+# Triggering an error
+risky_calculation(10, 0) 
+
+```
+
+**What happens next?**
+
+1. **Detection**: The `AutoHealerBot` detects the `ZeroDivisionError`.
+2. **Diagnosis**: It retrieves the source code and error stack trace.
+3. **Fix**: It uses an LLM to generate a patch (adding `try-except` or input validation).
+4. **Action**: A **Pull Request** is automatically created in your GitHub repository.
+
+![VectorWave Healer Architecture](./docs_kr/images/self_healing.png)
+
+
+##  Key Features
+
+### ⚡ Optimization Engine (Semantic Caching)
+
+Don't pay for the same computation twice. VectorWave uses **Weaviate** vector database to store and retrieve function results based on meaning, not just exact string matching.
+
+* **Latency**: Reduced from seconds to milliseconds.
+* **Cost**: Up to 90% reduction in LLM token usage.
+
+![VectorWave Semantic Caching Architecture](./docs_kr/images/detail_arch.png)
+
+
+###  Self-Healing & GitOps
+
+VectorWave doesn't just log errors; it acts on them.
+
+* **Automated Root Cause Analysis (RCA)** using RAG.
+* **GitOps Integration**: Generates actual code fixes and pushes them to a new branch.
+* **Cooldown Mechanism**: Prevents spamming PRs for the same error.
+
+###  Semantic Drift Radar
+
+Detect when your users are asking things your model wasn't designed for.
+
+* **Anomaly Detection**: Calculates the distance between new queries and your "Golden Dataset".
+* **Alerting**: Sends notifications (e.g., Discord) when drift exceeds the threshold (default 0.25).
+
+![VectorWave Drift Architecture](./docs_kr/images/semantic_drift.png)
+
+
+##  How does it work?
+
+Unlike traditional Key-Value caching (e.g., Redis), VectorWave understands **Context**.
+
+1. **Vectorization**: It converts function arguments into high-dimensional vectors using OpenAI or HuggingFace models.
+2. **Search**: It performs an Approximate Nearest Neighbor (ANN) search in the vector store.
+3. **Decision**:
+* If a neighbor is found within the `threshold` -> **Return Cached Result**.
+* If not -> **Execute Function** -> **Async Log to DB**.
+
+
+
+##  Performance Benchmark
+
+| Metric | Direct Execution | With VectorWave | Improvement |
+| --- | --- | --- | --- |
+| **Latency (Hit)** | ~2.5s (LLM API) | **~0.02s** | **125x Faster** |
+| **Cost (Hit)** | $0.03 / call | **$0.00** | **100% Savings** |
+| **Reliability** | Manual Fix Required | **Auto-PR Created** | **Autonomous** |
+
+##  Feature Comparison
+
+Why choose VectorWave over traditional semantic caches?
+
+| Feature | Traditional Tools (e.g., GPTCache) | **VectorWave** |
+| :--- | :---: | :---: |
+| **Semantic Caching** | O (Text-based) | **O (Execution Context)** |
+| **Self-Healing (Auto-Fix)** | X | **O (Autonomous)** |
+| **GitOps (Auto-PR)** | X | **O (Seamless)** |
+| **Semantic Drift Detection** | X | **O (Drift Radar)** |
+| **Zero-Config Setup** | △ (Setup Required) | **O (Decorator)** |
+
+## 😍 Contributing
+
+We are extremely open to contributions! Whether it's a new vectorizer, a better healing prompt, or just a typo fix.
+Please check our [Contribution Guide](./Contributing.md).

{vectorwave-0.2.8 → vectorwave-0.3.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 
 [project]
 name = "vectorwave"
-version = "0.2.8"
+version = "0.3.0"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]
@@ -30,7 +30,9 @@ dependencies = [
     "pydantic-settings>=2.0.0",
     "sentence-transformers",
     "requests",
-    "openai"
+    "openai",
+    "PyGithub",
+    "schedule"
 ]
 
 [project.urls]

{vectorwave-0.2.8 → vectorwave-0.3.0}/src/vectorwave/__init__.py

@@ -1,5 +1,5 @@
 from .core.decorator import vectorize
-from .database.db import initialize_database
+from .database.db import initialize_database, update_database_schema
 from .database.db_search import search_functions, search_executions, search_errors_by_message, search_functions_hybrid
 from .monitoring.tracer import trace_span
 from .search.rag_search import search_and_answer, analyze_trace_log
@@ -25,5 +25,6 @@ __all__ = [
     'VectorWaveReplayer',
     'SemanticReplayer',
     'VectorWaveDatasetManager',
-    'VectorWaveAutoInjector'
+    'VectorWaveAutoInjector',
+    'update_database_schema'
 ]

{vectorwave-0.2.8 → vectorwave-0.3.0}/src/vectorwave/batch/batch.py

@@ -27,11 +27,18 @@ class WeaviateBatchManager:
     Uses High-Performance Rust Core if available, otherwise falls back to Python.
     """
 
-    def __init__(self):
+    def __init__(self, host: Optional[str] = None, port: Optional[int] = None,
+                 grpc_port: Optional[int] = None, api_key: Optional[str] = None):
         self._initialized = False
         self.settings: WeaviateSettings = get_weaviate_settings()
         self.client: Optional[weaviate.WeaviateClient] = None
 
+        # Store dynamic connection params
+        self._host = host
+        self._port = port
+        self._grpc_port = grpc_port
+        self._api_key = api_key
+
         # Batch Configuration
         self.batch_threshold = self.settings.BATCH_THRESHOLD
         self.flush_interval = self.settings.FLUSH_INTERVAL_SECONDS
@@ -60,7 +67,13 @@ class WeaviateBatchManager:
     def _connect_client(self):
         """Attempts to connect to Weaviate."""
         try:
-            self.client = get_weaviate_client(self.settings)
+            if self._host is not None:
+                self.client = get_weaviate_client(
+                    host=self._host, port=self._port,
+                    grpc_port=self._grpc_port, api_key=self._api_key
+                )
+            else:
+                self.client = get_weaviate_client(self.settings)
             if self.client:
                 self._initialized = True
         except Exception as e:
@@ -171,6 +184,11 @@ class WeaviateBatchManager:
             except:
                 pass
 
-@lru_cache(None)
-def get_batch_manager() -> WeaviateBatchManager:
-    return WeaviateBatchManager()
+@lru_cache()
+def get_batch_manager(
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        grpc_port: Optional[int] = None,
+        api_key: Optional[str] = None
+) -> WeaviateBatchManager:
+    return WeaviateBatchManager(host=host, port=port, grpc_port=grpc_port, api_key=api_key)

{vectorwave-0.2.8 → vectorwave-0.3.0}/src/vectorwave/core/auto_injector.py

@@ -23,7 +23,7 @@ def create_smart_wrapper(original_func, root_wrapper):
         # Check for existing tracer at runtime
         tracer = current_tracer_var.get()
 
-        if tracer:
+        if tracer is not None:
             # [Case A] Parent trace exists -> Act as Child Span
             # (Wrap original function with trace_span and execute)
             return trace_span(original_func, capture_return_value=True)(*args, **kwargs)