@techwavedev/agi-agent-kit 1.1.3

package/templates/skills/core/qdrant-memory/scripts/embedding_utils.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Shared embedding utilities for the qdrant-memory skill.
+Supports Ollama (local), OpenAI (cloud), and Amazon Bedrock (AWS) embeddings.
+
+Usage:
+    from embedding_utils import get_embedding, get_embedding_dimension
+    
+    embedding = get_embedding("Your text here")
+    dim = get_embedding_dimension()
+
+Environment Variables:
+    EMBEDDING_PROVIDER  - "ollama" (default), "openai", or "bedrock"
+    
+    # Ollama (local/private)
+    OLLAMA_URL          - Ollama server URL (default: http://localhost:11434)
+    
+    # OpenAI (cloud)
+    OPENAI_API_KEY      - Required for OpenAI provider
+    
+    # Amazon Bedrock (AWS - uses your Kiro subscription)
+    AWS_PROFILE         - AWS profile name (default: uses default profile)
+    AWS_REGION          - AWS region (default: eu-west-1)
+    
+    EMBEDDING_MODEL     - Model name (defaults based on provider)
+
+Pricing Comparison:
+    - Ollama: FREE (local)
+    - Bedrock Titan Embed V2: ~$0.02/1M tokens (cheapest cloud)
+    - OpenAI text-embedding-3-small: ~$0.02/1M tokens
+"""
+
+import json
+import os
+from typing import List
+from urllib.request import Request, urlopen
+from urllib.error import URLError
+
+# Configuration with Ollama as default (local/private)
+EMBEDDING_PROVIDER = os.environ.get("EMBEDDING_PROVIDER", "ollama")
+OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434")
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+AWS_REGION = os.environ.get("AWS_REGION", "eu-west-1")
+
+# Model configurations
+PROVIDER_CONFIGS = {
+    "ollama": {
+        "default_model": "nomic-embed-text",
+        "dimensions": {
+            "nomic-embed-text": 768,
+            "mxbai-embed-large": 1024,
+            "all-minilm": 384,
+        },
+        "default_dim": 768
+    },
+    "openai": {
+        "default_model": "text-embedding-3-small",
+        "dimensions": {
+            "text-embedding-3-small": 1536,
+            "text-embedding-3-large": 3072,
+            "text-embedding-ada-002": 1536,
+        },
+        "default_dim": 1536
+    },
+    "bedrock": {
+        "default_model": "amazon.titan-embed-text-v2:0",
+        "dimensions": {
+            "amazon.titan-embed-text-v2:0": 1024,
+            "amazon.titan-embed-text-v1": 1536,
+            "cohere.embed-english-v3": 1024,
+            "cohere.embed-multilingual-v3": 1024,
+        },
+        "default_dim": 1024
+    }
+}
+
+EMBEDDING_MODEL = os.environ.get(
+    "EMBEDDING_MODEL", 
+    PROVIDER_CONFIGS.get(EMBEDDING_PROVIDER, {}).get("default_model", "nomic-embed-text")
+)
+
+
+def get_embedding_dimension() -> int:
+    """Get the dimension for the current embedding configuration."""
+    config = PROVIDER_CONFIGS.get(EMBEDDING_PROVIDER, PROVIDER_CONFIGS["ollama"])
+    return config["dimensions"].get(EMBEDDING_MODEL, config["default_dim"])
+
+
+def get_embedding_ollama(text: str) -> List[float]:
+    """Generate embedding using Ollama (local)."""
+    payload = {
+        "model": EMBEDDING_MODEL,
+        "prompt": text
+    }
+    
+    req = Request(
+        f"{OLLAMA_URL}/api/embeddings",
+        data=json.dumps(payload).encode(),
+        headers={"Content-Type": "application/json"},
+        method="POST"
+    )
+    
+    with urlopen(req, timeout=60) as response:
+        result = json.loads(response.read().decode())
+        return result["embedding"]
+
+
+def get_embedding_openai(text: str) -> List[float]:
+    """Generate embedding using OpenAI API."""
+    if not OPENAI_API_KEY:
+        raise ValueError("OPENAI_API_KEY environment variable not set")
+    
+    payload = {
+        "input": text,
+        "model": EMBEDDING_MODEL
+    }
+    
+    req = Request(
+        "https://api.openai.com/v1/embeddings",
+        data=json.dumps(payload).encode(),
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        },
+        method="POST"
+    )
+    
+    with urlopen(req, timeout=30) as response:
+        result = json.loads(response.read().decode())
+        return result["data"][0]["embedding"]
+
+
+def get_embedding_bedrock(text: str) -> List[float]:
+    """
+    Generate embedding using Amazon Bedrock.
+    
+    Uses boto3 with AWS credentials from:
+    - AWS_PROFILE environment variable
+    - ~/.aws/credentials (default profile)
+    - IAM role (if running on AWS)
+    
+    No secrets stored in code - uses standard AWS authentication.
+    """
+    try:
+        import boto3
+    except ImportError:
+        raise ImportError(
+            "boto3 is required for Bedrock embeddings. Install with: pip install boto3"
+        )
+    
+    # Create Bedrock client using AWS profile/credentials
+    session = boto3.Session(region_name=AWS_REGION)
+    bedrock = session.client("bedrock-runtime")
+    
+    # Prepare request based on model
+    if "titan-embed" in EMBEDDING_MODEL:
+        # Amazon Titan Embed format
+        body = json.dumps({
+            "inputText": text
+        })
+        content_type = "application/json"
+        accept = "application/json"
+    elif "cohere" in EMBEDDING_MODEL:
+        # Cohere Embed format
+        body = json.dumps({
+            "texts": [text],
+            "input_type": "search_document"
+        })
+        content_type = "application/json"
+        accept = "application/json"
+    else:
+        raise ValueError(f"Unsupported Bedrock model: {EMBEDDING_MODEL}")
+    
+    # Invoke the model
+    response = bedrock.invoke_model(
+        modelId=EMBEDDING_MODEL,
+        body=body,
+        contentType=content_type,
+        accept=accept
+    )
+    
+    # Parse response
+    result = json.loads(response["body"].read())
+    
+    if "titan-embed" in EMBEDDING_MODEL:
+        return result["embedding"]
+    elif "cohere" in EMBEDDING_MODEL:
+        return result["embeddings"][0]
+    
+    return result.get("embedding", result.get("embeddings", [[]])[0])
+
+
+def get_embedding(text: str) -> List[float]:
+    """
+    Generate embedding using the configured provider.
+    
+    Default: Ollama (local/private)
+    Override with EMBEDDING_PROVIDER environment variable.
+    
+    Providers:
+        - ollama: Local, free, private (default)
+        - bedrock: AWS Titan Embed V2 (~$0.02/1M tokens)
+        - openai: OpenAI API (~$0.02/1M tokens)
+    
+    Args:
+        text: Text to embed
+        
+    Returns:
+        List of floats representing the embedding vector
+        
+    Raises:
+        ValueError: If provider is not configured correctly
+        URLError: If unable to connect to embedding service
+    """
+    if EMBEDDING_PROVIDER == "ollama":
+        return get_embedding_ollama(text)
+    elif EMBEDDING_PROVIDER == "openai":
+        return get_embedding_openai(text)
+    elif EMBEDDING_PROVIDER == "bedrock":
+        return get_embedding_bedrock(text)
+    else:
+        raise ValueError(
+            f"Unknown embedding provider: {EMBEDDING_PROVIDER}. "
+            f"Use 'ollama', 'openai', or 'bedrock'."
+        )
+
+
+def check_embedding_service() -> dict:
+    """
+    Check if the embedding service is available.
+    
+    Returns:
+        Dict with status and details
+    """
+    try:
+        if EMBEDDING_PROVIDER == "ollama":
+            req = Request(f"{OLLAMA_URL}/api/tags", method="GET")
+            with urlopen(req, timeout=10) as response:
+                result = json.loads(response.read().decode())
+                models = [m["name"] for m in result.get("models", [])]
+                has_model = any(EMBEDDING_MODEL in m for m in models)
+                return {
+                    "status": "ok" if has_model else "missing_model",
+                    "provider": "ollama",
+                    "url": OLLAMA_URL,
+                    "model": EMBEDDING_MODEL,
+                    "available_models": models,
+                    "message": f"Model '{EMBEDDING_MODEL}' ready" if has_model else f"Run: ollama pull {EMBEDDING_MODEL}"
+                }
+        elif EMBEDDING_PROVIDER == "openai":
+            if not OPENAI_API_KEY:
+                return {
+                    "status": "missing_key",
+                    "provider": "openai",
+                    "model": EMBEDDING_MODEL,
+                    "message": "Set OPENAI_API_KEY environment variable"
+                }
+            return {
+                "status": "ok",
+                "provider": "openai",
+                "model": EMBEDDING_MODEL,
+                "message": "OpenAI API key configured"
+            }
+        elif EMBEDDING_PROVIDER == "bedrock":
+            try:
+                import boto3
+                session = boto3.Session(region_name=AWS_REGION)
+                sts = session.client("sts")
+                identity = sts.get_caller_identity()
+                return {
+                    "status": "ok",
+                    "provider": "bedrock",
+                    "model": EMBEDDING_MODEL,
+                    "region": AWS_REGION,
+                    "account": identity.get("Account", "unknown"),
+                    "message": f"AWS authenticated (account: {identity.get('Account', 'unknown')})"
+                }
+            except ImportError:
+                return {
+                    "status": "missing_boto3",
+                    "provider": "bedrock",
+                    "message": "Install boto3: pip install boto3"
+                }
+            except Exception as e:
+                return {
+                    "status": "auth_error",
+                    "provider": "bedrock",
+                    "message": f"AWS auth failed: {e}"
+                }
+        else:
+            return {
+                "status": "unknown_provider",
+                "provider": EMBEDDING_PROVIDER,
+                "message": f"Unknown provider. Use 'ollama', 'openai', or 'bedrock'."
+            }
+    except URLError as e:
+        return {
+            "status": "connection_error",
+            "provider": EMBEDDING_PROVIDER,
+            "message": str(e)
+        }
+
+
+if __name__ == "__main__":
+    # Quick test
+    import sys
+    
+    print(f"Embedding Provider: {EMBEDDING_PROVIDER}")
+    print(f"Model: {EMBEDDING_MODEL}")
+    print(f"Dimensions: {get_embedding_dimension()}")
+    print()
+    
+    status = check_embedding_service()
+    print(f"Service Status: {status['status']}")
+    print(f"Message: {status['message']}")
+    
+    if status["status"] == "ok":
+        try:
+            embedding = get_embedding("Test embedding generation")
+            print(f"\n✓ Embedding generated: {len(embedding)} dimensions")
+        except Exception as e:
+            print(f"\n✗ Error: {e}")
+            sys.exit(1)

package/templates/skills/core/qdrant-memory/scripts/hybrid_search.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+Script: hybrid_search.py
+Purpose: Hybrid search combining vector similarity with keyword filtering.
+
+Supports both Ollama (local/private) and OpenAI (cloud) embeddings.
+Default: Ollama with nomic-embed-text model.
+
+Usage:
+    python3 hybrid_search.py --query "kubernetes deployment failed" \\
+        --keyword error_code=ImagePullBackOff --keyword namespace=production
+
+This is particularly useful for technical queries where you need:
+- Semantic understanding (what is the user asking about?)
+- Exact matching (specific error codes, variable names, identifiers)
+
+Environment Variables:
+    EMBEDDING_PROVIDER  - "ollama" (default) or "openai"
+    OLLAMA_URL          - Ollama server URL (default: http://localhost:11434)
+    OPENAI_API_KEY      - Required for OpenAI provider
+    QDRANT_URL          - Qdrant server URL (default: http://localhost:6333)
+    MEMORY_COLLECTION   - Collection name (default: agent_memory)
+
+Exit Codes:
+    0 - Success (results found)
+    1 - No results
+    2 - Connection error
+    3 - Search error
+"""
+
+import argparse
+import json
+import os
+import sys
+from typing import List, Dict, Any, Optional
+from urllib.request import Request, urlopen
+from urllib.error import URLError
+
+# Import shared embedding utilities (supports Ollama and OpenAI)
+try:
+    from embedding_utils import get_embedding
+except ImportError:
+    # Fallback if run from different directory
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from embedding_utils import get_embedding
+
+# Configuration
+QDRANT_URL = os.environ.get("QDRANT_URL", "http://localhost:6333")
+COLLECTION = os.environ.get("MEMORY_COLLECTION", "agent_memory")
+
+
+def hybrid_query(
+    text_query: str,
+    keyword_filters: Optional[Dict[str, str]] = None,
+    must_not_filters: Optional[Dict[str, str]] = None,
+    top_k: int = 10,
+    score_threshold: float = 0.6
+) -> Dict[str, Any]:
+    """
+    Perform hybrid search combining vector similarity with keyword filtering.
+    
+    Args:
+        text_query: Natural language query for semantic search
+        keyword_filters: Dict of field:value pairs that MUST match
+        must_not_filters: Dict of field:value pairs that MUST NOT match
+        top_k: Number of results
+        score_threshold: Minimum similarity score
+    
+    Returns:
+        Search results with hybrid scores
+    """
+    # Get embedding for semantic search
+    embedding = get_embedding(text_query)
+    
+    # Build filter conditions
+    filter_conditions = {"must": [], "must_not": []}
+    
+    if keyword_filters:
+        for field, value in keyword_filters.items():
+            filter_conditions["must"].append({
+                "key": field,
+                "match": {"value": value}
+            })
+    
+    if must_not_filters:
+        for field, value in must_not_filters.items():
+            filter_conditions["must_not"].append({
+                "key": field,
+                "match": {"value": value}
+            })
+    
+    # Build search payload
+    search_payload = {
+        "vector": embedding,
+        "limit": top_k,
+        "score_threshold": score_threshold,
+        "with_payload": True
+    }
+    
+    # Only add filter if we have conditions
+    if filter_conditions["must"] or filter_conditions["must_not"]:
+        search_payload["filter"] = {
+            k: v for k, v in filter_conditions.items() if v
+        }
+    
+    req = Request(
+        f"{QDRANT_URL}/collections/{COLLECTION}/points/search",
+        data=json.dumps(search_payload).encode(),
+        headers={"Content-Type": "application/json"},
+        method="POST"
+    )
+    
+    with urlopen(req, timeout=30) as response:
+        result = json.loads(response.read().decode())
+    
+    results = []
+    for hit in result.get("result", []):
+        results.append({
+            "id": hit["id"],
+            "score": hit["score"],
+            "content": hit["payload"].get("content", ""),
+            "type": hit["payload"].get("type"),
+            "project": hit["payload"].get("project"),
+            "tags": hit["payload"].get("tags", []),
+            "timestamp": hit["payload"].get("timestamp"),
+            "matched_filters": keyword_filters or {}
+        })
+    
+    return {
+        "query": text_query,
+        "keyword_filters": keyword_filters,
+        "results": results,
+        "total": len(results),
+        "search_type": "hybrid" if keyword_filters else "semantic"
+    }
+
+
+def parse_keyword_args(keyword_args: List[str]) -> Dict[str, str]:
+    """Parse keyword arguments in format key=value."""
+    filters = {}
+    for kv in keyword_args or []:
+        if "=" in kv:
+            key, value = kv.split("=", 1)
+            filters[key.strip()] = value.strip()
+    return filters
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Hybrid search with vector + keyword filtering"
+    )
+    parser.add_argument(
+        "--query", 
+        required=True,
+        help="Natural language query"
+    )
+    parser.add_argument(
+        "--keyword",
+        action="append",
+        help="Keyword filter in key=value format (can be repeated)"
+    )
+    parser.add_argument(
+        "--exclude",
+        action="append",
+        help="Exclusion filter in key=value format (can be repeated)"
+    )
+    parser.add_argument(
+        "--top-k",
+        type=int,
+        default=10,
+        help="Number of results (default: 10)"
+    )
+    parser.add_argument(
+        "--threshold",
+        type=float,
+        default=0.6,
+        help="Minimum score threshold (default: 0.6)"
+    )
+    
+    args = parser.parse_args()
+    
+    try:
+        keyword_filters = parse_keyword_args(args.keyword)
+        exclude_filters = parse_keyword_args(args.exclude)
+        
+        result = hybrid_query(
+            text_query=args.query,
+            keyword_filters=keyword_filters if keyword_filters else None,
+            must_not_filters=exclude_filters if exclude_filters else None,
+            top_k=args.top_k,
+            score_threshold=args.threshold
+        )
+        
+        print(json.dumps(result, indent=2))
+        sys.exit(0 if result["total"] > 0 else 1)
+        
+    except URLError as e:
+        print(json.dumps({
+            "status": "error",
+            "type": "connection_error",
+            "message": str(e)
+        }), file=sys.stderr)
+        sys.exit(2)
+    except Exception as e:
+        print(json.dumps({
+            "status": "error",
+            "type": type(e).__name__,
+            "message": str(e)
+        }), file=sys.stderr)
+        sys.exit(3)
+
+
+if __name__ == "__main__":
+    main()