semantio 0.0.1__py3-none-any.whl

semantio/api/fastapi_app.py

@@ -0,0 +1,70 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from typing import Optional, Dict, List
+from ..agent import Agent
+
+def create_fastapi_app(agent: Agent, api_config: Optional[Dict] = None) -> FastAPI:
+    """
+    Create a FastAPI app for the given agent.
+
+    Args:
+        agent (Agent): The agent instance for which the API is being created.
+        api_config (Optional[Dict]): Configuration for the API, including CORS settings.
+
+    Returns:
+        FastAPI: A FastAPI app with endpoints for interacting with the agent.
+    """
+    app = FastAPI()
+
+    # Default CORS settings (allow all)
+    cors_config = {
+        "allow_origins": ["*"],
+        "allow_credentials": True,
+        "allow_methods": ["*"],
+        "allow_headers": ["*"],
+    }
+
+    # Override default CORS settings with user-provided settings
+    if api_config and "cors" in api_config:
+        cors_config.update(api_config["cors"])
+
+    # Add CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=cors_config["allow_origins"],
+        allow_credentials=cors_config["allow_credentials"],
+        allow_methods=cors_config["allow_methods"],
+        allow_headers=cors_config["allow_headers"],
+    )
+
+    @app.post("/chat")
+    async def chat(message: str):
+        """
+        Endpoint to interact with the agent.
+        """
+        response = agent.print_response(message=message)
+
+        if agent.json_output:
+            return response
+        else:
+            return {"response": response}
+
+    @app.get("/tools")
+    async def get_tools():
+        """
+        Endpoint to get the list of tools available to the agent.
+        """
+        return {"tools": agent.tools}
+
+    @app.post("/load_image")
+    async def load_image(image_url: str):
+        """
+        Endpoint to load an image from a URL.
+        """
+        try:
+            image = agent.load_image_from_url(image_url)
+            return {"status": "success", "image": "Image loaded successfully"}
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=str(e))
+
+    return app

semantio/cli/main.py

@@ -0,0 +1,31 @@
+import argparse
+import warnings
+from hashai.assistant import Assistant
+from hashai.llm import get_llm
+from urllib3.exceptions import NotOpenSSLWarning
+
+# Suppress the NotOpenSSLWarning
+warnings.filterwarnings("ignore", category=NotOpenSSLWarning)
+
+def main():
+    parser = argparse.ArgumentParser(description="opAi CLI")
+    parser.add_argument("--message", type=str, required=True, help="Message to send to the assistant")
+    parser.add_argument("--provider", type=str, required=True, help="LLM provider (e.g., groq, openai)")
+    parser.add_argument("--api-key", type=str, required=True, help="API key for the LLM provider")
+    parser.add_argument("--model", type=str, default=None, help="Model name (e.g., mixtral-8x7b-32768)")
+    args = parser.parse_args()
+
+    # Initialize LLM
+    llm_config = {"api_key": args.api_key}
+    if args.model:
+        llm_config["model"] = args.model
+
+    llm = get_llm(provider=args.provider, **llm_config)
+
+    # Create an assistant
+    assistant = Assistant(model=args.provider, llm=llm)
+    assistant.print_response(args.message)
+    
+
+if __name__ == "__main__":
+    main()

semantio/knowledge_base/__init__.py

@@ -0,0 +1,5 @@
+from .document_loader import DocumentLoader
+from .retriever import Retriever
+from .vector_store import VectorStore
+
+__all__ = ["DocumentLoader", "Retriever", "VectorStore"]

semantio/knowledge_base/document_loader.py

@@ -0,0 +1,61 @@
+from typing import List, Dict, Any
+from pathlib import Path
+
+class DocumentLoader:
+    """
+    A class to load documents from various sources (e.g., files, URLs) into the knowledge base.
+    """
+
+    def __init__(self):
+        """
+        Initialize the DocumentLoader.
+        """
+        pass
+
+    def load_from_file(self, file_path: str) -> List[Dict[str, Any]]:
+        """
+        Load documents from a file.
+
+        Args:
+            file_path (str): The path to the file.
+
+        Returns:
+            List[Dict[str, Any]]: A list of documents, where each document is a dictionary.
+        """
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Example: Load a JSON file
+        if file_path.suffix == ".json":
+            import json
+            with open(file_path, "r") as f:
+                return json.load(f)
+        # Example: Load a text file
+        elif file_path.suffix == ".txt":
+            with open(file_path, "r") as f:
+                return [{"text": f.read()}]
+        else:
+            raise ValueError(f"Unsupported file type: {file_path.suffix}")
+
+    def load_from_url(self, url: str) -> List[Dict[str, Any]]:
+        """
+        Load documents from a URL.
+
+        Args:
+            url (str): The URL to load documents from.
+
+        Returns:
+            List[Dict[str, Any]]: A list of documents, where each document is a dictionary.
+        """
+        import requests
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch data from URL: {url}")
+
+        # Example: Load JSON data from a URL
+        if "application/json" in response.headers.get("Content-Type", ""):
+            return response.json()
+        # Example: Load text data from a URL
+        else:
+            return [{"text": response.text}]

semantio/knowledge_base/retriever.py

@@ -0,0 +1,41 @@
+from typing import List, Dict
+import numpy as np
+
+class Retriever:
+    def __init__(self, vector_store):
+        self.vector_store = vector_store
+
+    def retrieve(self, query: str, k: int = 5) -> List[Dict]:
+        """
+        Retrieve relevant documents for a given query.
+
+        Args:
+            query (str): The query string.
+            k (int): Number of documents to retrieve.
+
+        Returns:
+            List[Dict]: List of relevant documents.
+        """
+        # Convert the query to an embedding (dummy implementation for now)
+        query_embedding = self._embed_query(query)
+
+        # Search the vector store for similar embeddings
+        indices = self.vector_store.search(query_embedding, k=k)
+
+        # Retrieve the documents (dummy implementation for now)
+        documents = [{"content": f"Document {i}", "score": 0.9} for i in indices]
+
+        return documents
+
+    def _embed_query(self, query: str) -> np.ndarray:
+        """
+        Convert a query string to an embedding.
+
+        Args:
+            query (str): The query string.
+
+        Returns:
+            np.ndarray: The query embedding.
+        """
+        # Dummy implementation: return a random embedding
+        return np.random.rand(768)  # Assuming 768-dimensional embeddings

semantio/knowledge_base/vector_store.py

@@ -0,0 +1,35 @@
+import numpy as np
+import faiss
+
+class VectorStore:
+    def __init__(self, dimension: int = 768):
+        """
+        Initialize a vector store.
+
+        Args:
+            dimension (int): Dimensionality of the embeddings.
+        """
+        self.index = faiss.IndexFlatL2(dimension)
+
+    def add_embeddings(self, embeddings: np.ndarray):
+        """
+        Add embeddings to the vector store.
+
+        Args:
+            embeddings (np.ndarray): Array of embeddings to add.
+        """
+        self.index.add(embeddings)
+
+    def search(self, query_embedding: np.ndarray, k: int = 5) -> np.ndarray:
+        """
+        Search for similar embeddings.
+
+        Args:
+            query_embedding (np.ndarray): The query embedding.
+            k (int): Number of nearest neighbors to retrieve.
+
+        Returns:
+            np.ndarray: Indices of the nearest neighbors.
+        """
+        distances, indices = self.index.search(query_embedding.reshape(1, -1), k)
+        return indices[0]

semantio/llm/__init__.py

@@ -0,0 +1,17 @@
+from .openai import OpenAILlm
+from .anthropic import AnthropicLlm
+# from .llama import LlamaLlm
+from .groq import GroqLlm
+
+def get_llm(provider: str, **kwargs):
+    provider = provider.lower()  # Convert provider name to lowercase
+    if provider == "openai":
+        return OpenAILlm(**kwargs)
+    elif provider == "anthropic":
+        return AnthropicLlm(**kwargs)
+    # elif provider == "llama":
+    #     return LlamaLlm(**kwargs)
+    elif provider == "groq":
+        return GroqLlm(**kwargs)
+    else:
+        raise ValueError(f"Unsupported LLM provider: {provider}")

semantio/llm/anthropic.py

@@ -0,0 +1,39 @@
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+import anthropic
+import os
+
+class AnthropicLlm(BaseLLM):
+    def __init__(
+        self,
+        model: str = "claude-2.1",  # Default Anthropic model
+        api_key: Optional[str] = None,
+    ):
+        self.model = model
+        self.api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
+        if not self.api_key:
+            raise ValueError("Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or pass it explicitly.")
+        self.client = anthropic.Client(api_key=self.api_key)
+
+    def generate(
+        self,
+        prompt: str,
+        context: Optional[List[Dict]] = None,
+        memory: Optional[List[Dict]] = None,
+    ) -> str:
+        # Prepare messages for the Anthropic API
+        messages = []
+        if memory:
+            messages.extend(memory)
+        if context:
+            messages.append({"role": "system", "content": "Context: " + str(context)})
+        messages.append({"role": "user", "content": prompt})
+
+        # Call Anthropic API
+        response = self.client.completion(
+            model=self.model,
+            messages=messages,
+        )
+
+        # Extract and return the response
+        return response.choices[0].message.content

semantio/llm/base_llm.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional
+
+class BaseLLM(ABC):
+    @abstractmethod
+    def generate(
+        self,
+        prompt: str,
+        context: Optional[List[Dict]] = None,
+        memory: Optional[List[Dict]] = None,
+    ) -> str:
+        pass

semantio/llm/groq.py

@@ -0,0 +1,39 @@
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+import groq
+import os
+
+class GroqLlm(BaseLLM):
+    def __init__(
+        self,
+        model: str = "mixtral-8x7b-32768",  # Default Groq model
+        api_key: Optional[str] = None,
+    ):
+        self.model = model
+        self.api_key = api_key or os.getenv("GROQ_API_KEY")
+        if not self.api_key:
+            raise ValueError("Groq API key is required. Set GROQ_API_KEY environment variable or pass it explicitly.")
+        self.client = groq.Client(api_key=self.api_key)
+
+    def generate(
+        self,
+        prompt: str,
+        context: Optional[List[Dict]] = None,
+        memory: Optional[List[Dict]] = None,
+    ) -> str:
+        # Prepare messages for the Groq API
+        messages = []
+        if memory:
+            messages.extend(memory)
+        if context:
+            messages.append({"role": "system", "content": "Context: " + str(context)})
+        messages.append({"role": "user", "content": prompt})
+
+        # Call Groq API
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+        )
+
+        # Extract and return the response
+        return response.choices[0].message.content

semantio/llm/openai.py

@@ -0,0 +1,26 @@
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+import openai
+import os
+
+class OpenAILlm(BaseLLM):
+    def __init__(self, model: str = "gpt-4", api_key: Optional[str] = None):
+        self.model = model
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it explicitly.")
+        openai.api_key = self.api_key
+
+    def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
+        messages = []
+        if memory:
+            messages.extend(memory)
+        if context:
+            messages.append({"role": "system", "content": "Context: " + str(context)})
+        messages.append({"role": "user", "content": prompt})
+
+        response = openai.ChatCompletion.create(
+            model=self.model,
+            messages=messages,
+        )
+        return response.choices[0].message["content"]

semantio/memory.py

@@ -0,0 +1,11 @@
+from typing import List, Dict
+
+class Memory:
+    def __init__(self):
+        self.history = []
+
+    def add_message(self, role: str, content: str):
+        self.history.append({"role": role, "content": content})
+
+    def get_history(self) -> List[Dict]:
+        return self.history

semantio/rag.py

@@ -0,0 +1,18 @@
+from typing import List, Dict
+from .knowledge_base.retriever import Retriever
+
+class RAG:
+    def __init__(self, retriever: Retriever):
+        self.retriever = retriever
+
+    def retrieve(self, query: str) -> List[Dict]:
+        """
+        Retrieve relevant context for a given query.
+
+        Args:
+            query (str): The query string.
+
+        Returns:
+            List[Dict]: List of relevant documents.
+        """
+        return self.retriever.retrieve(query)

semantio/tools/base_tool.py

@@ -0,0 +1,12 @@
+# base_tool.py
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, Field
+
+class BaseTool(BaseModel):
+    name: str = Field(..., description="The name of the tool.")
+    description: str = Field(..., description="A brief description of the tool's functionality.")
+    llm: Optional[Any] = Field(None, description="The LLM instance to use for tool execution.")
+
+    def execute(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool's functionality."""
+        raise NotImplementedError("Subclasses must implement this method.")

semantio/tools/crypto.py

@@ -0,0 +1,133 @@
+from .base_tool import BaseTool
+import yfinance as yf
+from typing import Dict, Any, List, Optional
+from pydantic import Field
+import logging
+import re
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class CryptoPriceChecker(BaseTool):
+    default_symbol: str = Field(default="BTC-USD", description="Default cryptocurrency symbol (e.g., 'BTC-USD').")
+    enable_historical_data: bool = Field(default=True, description="Enable fetching historical data.")
+    enable_multiple_symbols: bool = Field(default=True, description="Enable fetching data for multiple cryptocurrencies.")
+    enable_metrics: bool = Field(default=True, description="Enable additional metrics like volume and market cap.")
+    llm: Optional[Any] = Field(None, description="The LLM instance to use for symbol extraction.")
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="CryptoPriceChecker",
+            description="Fetch real-time and historical cryptocurrency prices and metrics.",
+            **kwargs
+        )
+
+    def execute(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute the cryptocurrency price check based on the provided input.
+
+        Args:
+            input_data (Dict[str, Any]): Input data containing the query and optional parameters.
+
+        Returns:
+            Dict[str, Any]: Cryptocurrency price and additional metrics.
+        """
+        try:
+            query = input_data.get("query", "")
+            symbols = self._extract_symbols(query) if query else [self.default_symbol]
+            time_range = input_data.get("time_range", "1d")  # Default to 1 day
+            metrics = input_data.get("metrics", ["price"])  # Default to price only
+
+            results = {}
+
+            for symbol in symbols:
+                # Validate the symbol
+                if not self._is_valid_symbol(symbol):
+                    logger.warning(f"Invalid cryptocurrency symbol: {symbol}")
+                    results[symbol] = {"error": "Invalid symbol"}
+                    continue
+
+                try:
+                    crypto = yf.Ticker(symbol)
+                    data = {}
+
+                    # Fetch real-time price
+                    if "price" in metrics:
+                        history = crypto.history(period=time_range)
+                        if not history.empty:
+                            data["price"] = history["Close"].iloc[-1]
+                        else:
+                            data["price"] = "No data available"
+
+                    # Fetch historical data
+                    if self.enable_historical_data and "history" in metrics:
+                        history = crypto.history(period=time_range)
+                        if not history.empty:
+                            data["history"] = history.to_dict()
+                        else:
+                            data["history"] = "No historical data available"
+
+                    # Fetch additional metrics
+                    if self.enable_metrics:
+                        info = crypto.info
+                        if "volume" in metrics:
+                            data["volume"] = info.get("volume24Hr", "No volume data available")
+                        if "market_cap" in metrics:
+                            data["market_cap"] = info.get("marketCap", "No market cap data available")
+
+                    results[symbol] = data
+                except Exception as e:
+                    results[symbol] = {"error": str(e)}
+
+            return results
+        except Exception as e:
+            return {"error": str(e)}
+
+    def _extract_symbols(self, query: str) -> List[str]:
+        """
+        Use the LLM to extract cryptocurrency symbols from the user's query.
+        """
+        if not self.llm:
+            logger.error("LLM instance not available for symbol extraction.")
+            return []
+
+        # Create a prompt for the LLM
+        prompt = f"""
+        Extract the cryptocurrency symbols from the following user query. 
+        Return the symbols as a comma-separated list in the format CRYPTO-FIAT (e.g., "BTC-USD,ETH-USD"). 
+        If no symbols are found, return "None".
+
+        User Query: "{query}"
+        """
+
+        try:
+            # Call the LLM to generate the response
+            response = self.llm.generate(prompt=prompt)
+            logger.info(f"LLM response: {response}")
+            symbols = response.strip().replace('"', '').replace("'", "")
+
+            # Fallback: Extract symbols from verbose responses
+            if ":" in symbols or "\n" in symbols:
+                # Look for patterns like "BTC-USD,ETH-USD" in the response
+                symbol_pattern = re.compile(r"\b[A-Z]{2,5}-[A-Z]{2,5}\b")
+                symbols = ",".join(symbol_pattern.findall(symbols))
+                logger.info(f"Extracted symbols: {symbols}")
+
+            # Parse the response into a list of symbols
+            if symbols.lower() == "none":
+                return []
+            return [s.strip() for s in symbols.split(",")]
+        except Exception as e:
+            logger.error(f"Failed to extract symbols: {e}")
+            return []
+
+    def _is_valid_symbol(self, symbol: str) -> bool:
+        """
+        Validate if the symbol is a valid cryptocurrency symbol.
+        """
+        # Check if the symbol follows the CRYPTO-FIAT format (e.g., BTC-USD, ETH-USD)
+        if "-" not in symbol:
+            return False
+        crypto, fiat = symbol.split("-")
+        return bool(crypto.strip()) and bool(fiat.strip())