ai-parrot 0.8.3__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

parrot/bots/tools/eda.py

@@ -0,0 +1,325 @@
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+
+import matplotlib.pyplot as plt
+# Import profiling
+from ydata_profiling import ProfileReport
+import seaborn as sns
+import pandas as pd
+import base64
+import io
+from html import escape
+import os
+from datetime import datetime
+import re
+
+
+def df_to_html_with_style(df_input, title=""):
+    """Converts a DataFrame to an HTML table with some basic styling."""
+    styler = df_input.style.set_table_attributes('class="dataframe"')
+    if title:
+        styler = styler.set_caption(title)
+    # You can add more complex styling here if needed
+    # e.g., .format('{:.2f}') for floats, add bar charts, etc.
+    return styler.to_html()
+
+
+def plot_to_base64(plt_figure):
+    """Saves the current matplotlib figure to a base64 encoded string."""
+    buf = io.BytesIO()
+    plt_figure.savefig(buf, format='png', bbox_inches='tight')
+    buf.seek(0)
+    img_base64 = base64.b64encode(buf.read()).decode('utf-8')
+    buf.close()
+    plt.close(plt_figure) # Close the figure to free memory
+    return img_base64
+
+
+def generate_eda_report(dataframe=None, report_dir=None, df_name="DataFrame", minimal=False, explorative=True):
+    """Generates a ydata-profiling report and saves it to an HTML file.
+
+    Args:
+        dataframe: The pandas DataFrame to profile (defaults to 'df' if None)
+        df_name: Name to use in the report title and filename
+        minimal: Set to True for faster, less detailed reports
+        explorative: Set to True for detailed explorative analysis
+
+    Returns:
+        dict: Contains file path and other metadata
+    """
+    try:
+        # Use provided dataframe or default to df
+        df_to_profile = dataframe if dataframe is not None else None
+
+        # Generate timestamp for the filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        # Create filename with timestamp
+        output_filename = f"profile_report_{df_name}_{timestamp}.html"
+        output_path = os.path.join(report_dir, output_filename)
+
+        # Configure report options
+        config_kwargs = {
+            "title": f"Profiling Report for {df_name}",
+            "progress_bar": False,
+            "minimal": minimal,
+            "explorative": explorative
+        }
+
+        print(
+            f"Generating profile report for dataframe with shape {df_to_profile.shape}..."
+        )
+
+        # Generate the report (might take a while for large datasets)
+        profile = ProfileReport(df_to_profile, **config_kwargs)
+
+        # Save to file
+        profile.to_file(output_path)
+
+        print(f"✅ Profile report saved to: {output_path}")
+
+        # Return structured info with file path
+        return {
+            "type": "file",
+            "file_type": "html",
+            "message": "Profile report generated successfully",
+            "file_path": output_path,
+            "report_url": f"file://{os.path.abspath(output_path)}",
+            "df_name": df_name,
+            "df_shape": df_to_profile.shape
+        }
+
+    except Exception as e:
+        print(f"❌ Error generating profile report: {str(e)}")
+        return {
+            "type": "error",
+            "message": f"Failed to generate profile report: {str(e)}"
+        }
+
+
+def quick_eda(dataframe=None, report_dir=None):
+    """Performs a quick Exploratory Data Analysis (EDA) on a pandas DataFrame
+    and saves the results as an HTML file in the agent_report_dir directory."""
+    # Create the directory if it doesn't exist
+    os.makedirs(report_dir, exist_ok=True)
+
+    # Generate a timestamp for the filename
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    # Create filename if not provided
+    output_filename = f"eda_report_{timestamp}.html"
+
+    # Create full path
+    output_path = os.path.join(report_dir, output_filename)
+
+    df_to_analyze = dataframe if dataframe is not None else None
+    if not isinstance(df_to_analyze, pd.DataFrame):
+        return "<p>Error: Input is not a valid pandas DataFrame.</p>"
+
+    html_parts = []
+
+    # --- Basic HTML Setup and Styling ---
+    html_parts.append("""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Quick EDA Report</title>
+        <style>
+            body { font-family: sans-serif; margin: 20px; }
+            h1, h2, h3 { color: #333; border-bottom: 1px solid #ccc; padding-bottom: 5px; }
+            h2 { margin-top: 30px; }
+            .dataframe { border-collapse: collapse; margin: 15px 0; font-size: 0.9em; }
+            .dataframe th, .dataframe td { border: 1px solid #ddd; padding: 8px; }
+            .dataframe th { background-color: #f2f2f2; text-align: left; }
+            .dataframe caption { caption-side: top; font-weight: bold; margin-bottom: 5px; text-align: left; font-size: 1.1em; }
+            img { max-width: 100%; height: auto; display: block; margin: 15px 0; border: 1px solid #eee; }
+            .plot-container { margin-bottom: 20px; }
+            .section { margin-bottom: 40px; padding: 15px; background-color: #f9f9f9; border-radius: 5px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+            .missing-values { color: #d9534f; } /* Style for missing values count */
+        </style>
+    </head>
+    <body>
+    """)
+    html_parts.append("<h1>📊 Quick EDA Report</h1>")
+
+    # --- Basic Info ---
+    html_parts.append('<div class="section">')
+    html_parts.append("<h2>📏 Basic Information</h2>")
+    html_parts.append(f"<p>Shape: {df_to_analyze.shape[0]} rows, {df_to_analyze.shape[1]} columns</p>")
+    html_parts.append('</div>')
+
+    # --- Data Types ---
+    html_parts.append('<div class="section">')
+    html_parts.append("<h2>📋 Data Types</h2>")
+    dtypes_df = df_to_analyze.dtypes.to_frame(name='DataType')
+    html_parts.append(df_to_html_with_style(dtypes_df))
+    html_parts.append('</div>')
+
+    # --- Missing Values ---
+    html_parts.append('<div class="section">')
+    html_parts.append("<h2><span class='missing-values'>🔍 Missing Values</span></h2>")
+    missing = df_to_analyze.isna().sum()
+    missing_filtered = missing[missing > 0]
+    if not missing_filtered.empty:
+        missing_df = missing_filtered.to_frame(name='Missing Count')
+        missing_df['Percentage (%)'] = (missing_df['Missing Count'] / len(df_to_analyze) * 100).round(2)
+        html_parts.append(df_to_html_with_style(missing_df))
+    else:
+        html_parts.append("<p>No missing values found.</p>")
+    html_parts.append('</div>')
+
+    # --- Descriptive Statistics ---
+    html_parts.append('<div class="section">')
+    html_parts.append("<h2>📈 Descriptive Statistics (Numerical Columns)</h2>")
+    try:
+        desc_stats = df_to_analyze.describe().T
+        if not desc_stats.empty:
+            html_parts.append(df_to_html_with_style(desc_stats.round(3))) # Round for clarity
+        else:
+            html_parts.append("<p>No numerical columns to describe.</p>")
+    except Exception as e:
+        html_parts.append(f"<p>Could not generate descriptive statistics: {escape(str(e))}</p>")
+    html_parts.append('</div>')
+
+    # --- Correlations for numerical columns ---
+    numeric_cols = df_to_analyze.select_dtypes(include=['number']).columns.tolist()
+    if len(numeric_cols) > 1:
+        html_parts.append('<div class="section">')
+        html_parts.append("<h2>🔗 Correlation Matrix (Numerical Columns)</h2>")
+        try:
+            fig_corr, ax_corr = plt.subplots(figsize=(10, 8))
+            corr = df_to_analyze[numeric_cols].corr()
+            sns.heatmap(corr, annot=True, cmap='coolwarm', fmt=".2f", ax=ax_corr)
+            ax_corr.set_title("Correlation Matrix")
+            # plt.tight_layout() # Often handled by bbox_inches='tight' in savefig
+
+            img_base64 = plot_to_base64(fig_corr)
+            html_parts.append(f'<img src="data:image/png;base64,{img_base64}" alt="Correlation Matrix">')
+        except Exception as e:
+            html_parts.append(f"<p>Could not generate correlation matrix plot: {escape(str(e))}</p>")
+            if 'fig_corr' in locals() and plt.fignum_exists(fig_corr.number): plt.close(fig_corr) # Ensure plot is closed on error
+        html_parts.append('</div>')
+    elif len(numeric_cols) <= 1:
+        html_parts.append('<div class="section">')
+        html_parts.append("<h2>🔗 Correlation Matrix (Numerical Columns)</h2>")
+        html_parts.append("<p>Not enough numerical columns (need at least 2) to calculate correlations.</p>")
+        html_parts.append('</div>')
+
+
+    # --- Distribution of numerical columns ---
+    if numeric_cols:
+        html_parts.append('<div class="section">')
+        html_parts.append("<h2>📊 Numerical Distributions (Sample)</h2>")
+        # Limit to avoid overly large HTML files
+        cols_to_plot = numeric_cols[:min(len(numeric_cols), 5)]
+        html_parts.append(f"<p>Displaying distributions for the first {len(cols_to_plot)} numerical columns: {', '.join(map(escape, cols_to_plot))}</p>")
+
+        for col in cols_to_plot:
+            html_parts.append('<div class="plot-container">')
+            html_parts.append(f"<h3>Distribution of {escape(col)}</h3>")
+            try:
+                # Create a figure with two subplots
+                fig_dist, axes = plt.subplots(1, 2, figsize=(12, 4))
+
+                # Histogram
+                sns.histplot(df_to_analyze[col].dropna(), kde=True, ax=axes[0])
+                axes[0].set_title(f"Histogram of {escape(col)}")
+
+                # Boxplot
+                sns.boxplot(y=df_to_analyze[col].dropna(), ax=axes[1])
+                axes[1].set_title(f"Boxplot of {escape(col)}")
+
+                fig_dist.tight_layout()
+                img_base64 = plot_to_base64(fig_dist)
+                html_parts.append(f'<img src="data:image/png;base64,{img_base64}" alt="Distribution plot for {escape(col)}">')
+
+            except Exception as e:
+                html_parts.append(f"<p>Could not generate distribution plot for {escape(col)}: {escape(str(e))}</p>")
+                # Ensure plot is closed even if error occurs after figure creation
+                if 'fig_dist' in locals() and plt.fignum_exists(fig_dist.number): plt.close(fig_dist)
+            html_parts.append('</div>') # End plot-container
+        html_parts.append('</div>') # End section
+
+
+    # --- Top values for categorical columns ---
+    cat_cols = df_to_analyze.select_dtypes(include=['object', 'category']).columns.tolist()
+    if cat_cols:
+        html_parts.append('<div class="section">')
+        html_parts.append("<h2>📊 Categorical Value Counts (Sample)</h2>")
+        # Limit to avoid overly large HTML files
+        cols_to_plot = cat_cols[:min(len(cat_cols), 5)]
+        html_parts.append(f"<p>Displaying value counts and plots for the first {len(cols_to_plot)} categorical columns: {', '.join(map(escape, cols_to_plot))}</p>")
+
+        for col in cols_to_plot:
+            html_parts.append('<div class="plot-container">')
+            html_parts.append(f"<h3>Value Counts for: {escape(col)}</h3>")
+            try:
+                # Value Counts Table (Top 10)
+                value_counts = df_to_analyze[col].value_counts().head(10)
+                if not value_counts.empty:
+                    vc_df = value_counts.to_frame(name='Count')
+                    vc_df['Percentage (%)'] = (vc_df['Count'] / len(df_to_analyze[col].dropna()) * 100).round(2) # Pct of non-missing
+                    html_parts.append(df_to_html_with_style(vc_df, title=f"Top {len(value_counts)} values"))
+
+                    # Create bar chart for top categories
+                    fig_cat, ax_cat = plt.subplots(figsize=(10, 5))
+                    value_counts.plot(kind='bar', ax=ax_cat)
+                    ax_cat.set_title(f"Top {len(value_counts)} values in {escape(col)}")
+                    ax_cat.set_ylabel("Count")
+                    ax_cat.set_xlabel(escape(col))
+                    plt.xticks(rotation=45, ha='right')
+                    fig_cat.tight_layout()
+
+                    img_base64 = plot_to_base64(fig_cat)
+                    html_parts.append(f'<img src="data:image/png;base64,{img_base64}" alt="Bar chart for top values in {escape(col)}">')
+                else:
+                    html_parts.append("<p>No values found for this column.</p>")
+
+            except Exception as e:
+                html_parts.append(f"<p>Could not generate value counts/plot for {escape(col)}: {escape(str(e))}</p>")
+                if 'fig_cat' in locals() and plt.fignum_exists(fig_cat.number): plt.close(fig_cat)
+
+            html_parts.append('</div>') # End plot-container
+        html_parts.append('</div>') # End section
+    elif not cat_cols:
+        html_parts.append('<div class="section">')
+        html_parts.append("<h2>📊 Categorical Value Counts</h2>")
+        html_parts.append("<p>No categorical columns found.</p>")
+        html_parts.append('</div>')
+
+    # --- Footer ---
+    html_parts.append('<hr><p style="text-align:center; color: #666; font-size: 0.9em;">✅ Quick EDA Report Generated</p>')
+    html_parts.append("</body></html>")
+
+    # --- Combine and write to file ---
+    html_content = "\n".join(html_parts)
+
+    # Write the HTML content to the file
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(html_content)
+
+    print(f"✅ EDA report saved to: {output_path}")
+    return {
+        "message": "EDA completed successfully",
+        "file_path": output_path,
+        "report_url": f"file://{os.path.abspath(output_path)}"
+    }
+
+def list_available_dataframes():
+    # List all available dataframes in the current session.
+
+    # Get all variables in the current scope
+    all_vars = list(globals().items())
+
+    # Filter for pandas DataFrames
+    dfs = [
+        (name, obj) for name, obj in all_vars if isinstance(obj, pd.DataFrame)
+    ]
+
+    print(f"Found {len(dfs)} dataframes:")
+    for name, df in dfs:
+        print(f"- {name}: {df.shape[0]} rows × {df.shape[1]} columns")
+
+    return [name for name, _ in dfs]

parrot/bots/tools/pdf.py

@@ -0,0 +1,50 @@
+import os
+from datetime import datetime
+from weasyprint import HTML, CSS
+from weasyprint.text.fonts import FontConfiguration
+
+
+def generate_pdf_from_html(html_content, report_dir):
+    """Generate a PDF file from HTML content.
+
+    Args:
+        html_content (str): HTML content to be converted to PDF.
+
+    """
+    # Create a FontConfiguration object
+    font_config = FontConfiguration()
+
+    # Additional CSS specifically for PDF rendering
+    pdf_css = CSS(string='''
+        @page {
+            size: letter;
+            margin: 1cm;
+            @top-center {
+                content: "Payroll Attestation Report";
+                font-size: 9pt;
+                color: #666;
+            }
+            @bottom-right {
+                content: "Page " counter(page) " of " counter(pages);
+                font-size: 9pt;
+                color: #666;
+            }
+        }
+        h1 { page-break-before: always; }
+        table { page-break-inside: avoid; }
+    ''', font_config=font_config)
+
+    # Generate timestamp for the filename
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    # Create filename with timestamp
+    output_filename = f"report_{timestamp}.html"
+    output_path = os.path.join(report_dir, output_filename)
+
+    # Convert HTML to PDF
+    HTML(string=html_content).write_pdf(
+        output_path,
+        stylesheets=[pdf_css],
+        font_config=font_config
+    )
+
+    return output_path

parrot/bots/tools/plot.py

@@ -0,0 +1,48 @@
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+# Adjust the Warning Threshold
+mpl.rcParams['figure.max_open_warning'] = 50  # Default is 20
+
+
+def create_plot(
+    dataframe,
+    x=None,
+    y=None,
+    kind='line',
+    title=None,
+    xlabel=None,
+    ylabel=None,
+    figsize=(10, 6),
+    save_path=None
+):
+    """Create and save a plot with proper cleanup."""
+    import matplotlib.pyplot as plt
+
+    try:
+        # Create the plot
+        fig, ax = plt.subplots(figsize=figsize)
+
+        if kind == 'line':
+            dataframe.plot(x=x, y=y, kind=kind, ax=ax)
+        elif kind == 'bar':
+            dataframe.plot(x=x, y=y, kind=kind, ax=ax)
+        # Add more plot types as needed
+
+        # Add labels and title
+        if xlabel:
+            ax.set_xlabel(xlabel)
+        if ylabel:
+            ax.set_ylabel(ylabel)
+        if title:
+            ax.set_title(title)
+
+        # Save if path provided
+        if save_path:
+            plt.savefig(save_path, bbox_inches='tight')
+            return save_path
+
+        return fig
+    finally:
+        # Always close the figure to prevent memory leaks
+        plt.close(fig)

parrot/bots/troc.py

@@ -0,0 +1,16 @@
+from .chatbot import Chatbot
+
+class AskTROC(Chatbot):
+    """Represents an Human Resources agent in Navigator.
+
+        Each agent has a name, a role, a goal, a backstory,
+        and an optional language model (llm).
+    """
+    company_information: dict = {
+        'company': 'T-ROC Global',
+        'company_website': 'https://www.trocglobal.com',
+        'contact_email': 'communications@trocglobal.com',
+        'contact_form': 'https://www.surveymonkey.com/r/TROC_Suggestion_Box'
+    }
+    role: str = 'Expert T-ROCer'
+    goal = 'Bring useful information about T-ROC Global to employees.'

parrot/conf.py

@@ -0,0 +1,170 @@
+from pathlib import Path
+from navconfig import config, BASE_DIR
+from navconfig.logging import logging
+from navigator.conf import default_dsn, CACHE_HOST, CACHE_PORT
+
+
+# disable debug on some libraries:
+logging.getLogger(name='httpcore').setLevel(logging.INFO)
+logging.getLogger(name='httpx').setLevel(logging.INFO)
+logging.getLogger(name='groq').setLevel(logging.INFO)
+logging.getLogger(name='selenium.webdriver').setLevel(logging.WARNING)
+logging.getLogger(name='selenium').setLevel(logging.INFO)
+logging.getLogger(name='matplotlib').setLevel(logging.WARNING)
+logging.getLogger(name='PIL').setLevel(logging.INFO)
+logging.getLogger("grpc").setLevel(logging.CRITICAL)
+
+
+# Static directory
+STATIC_DIR = config.get('STATIC_DIR', fallback=BASE_DIR.joinpath('static'))
+if isinstance(STATIC_DIR, str):
+    STATIC_DIR = Path(STATIC_DIR)
+
+# LLM Model
+DEFAULT_LLM_MODEL_NAME = config.get('LLM_MODEL_NAME', fallback='gemini-pro')
+
+
+## MILVUS DB ##:
+MILVUS_HOST = config.get('MILVUS_HOST', fallback='localhost')
+MILVUS_PROTOCOL = config.get('MILVUS_PROTOCOL', fallback='http')
+MILVUS_PORT = config.get('MILVUS_PORT', fallback=19530)
+MILVUS_URL = config.get('MILVUS_URL')
+MILVUS_TOKEN = config.get('MILVUS_TOKEN')
+MILVUS_USER = config.get('MILVUS_USER')
+MILVUS_PASSWORD = config.get('MILVUS_PASSWORD')
+MILVUS_SECURE = config.getboolean('MILVUS_SECURE', fallback=False)
+MILVUS_SERVER_NAME = config.get(
+    'MILVUS_SERVER_NAME'
+)
+MILVUS_CA_CERT = config.get('MILVUS_CA_CERT', fallback=None)
+MILVUS_SERVER_CERT = config.get('MILVUS_SERVER_CERT', fallback=None)
+MILVUS_SERVER_KEY = config.get('MILVUS_SERVER_KEY', fallback=None)
+MILVUS_USE_TLSv2 = config.getboolean('MILVUS_USE_TLSv2', fallback=False)
+
+# ScyllaDB Database:
+SCYLLADB_DRIVER = config.get('SCYLLADB_DRIVER', fallback='scylladb')
+SCYLLADB_HOST = config.get('SCYLLADB_HOST', fallback='localhost')
+SCYLLADB_PORT = int(config.get('SCYLLADB_PORT', fallback=9042))
+SCYLLADB_USERNAME = config.get('SCYLLADB_USERNAME', fallback='navigator')
+SCYLLADB_PASSWORD = config.get('SCYLLADB_PASSWORD', fallback='navigator')
+SCYLLADB_KEYSPACE = config.get('SCYLLADB_KEYSPACE', fallback='navigator')
+
+
+# BigQuery Configuration:
+BIGQUERY_CREDENTIALS = config.get('BIGQUERY_CREDENTIALS')
+BIGQUERY_PROJECT_ID = config.get('BIGQUERY_PROJECT_ID', fallback='navigator')
+BIGQUERY_DATASET = config.get('BIGQUERY_DATASET', fallback='navigator')
+
+# Redis History Configuration:
+REDIS_HISTORY_DB = config.get('REDIS_HISTORY_DB', fallback=3)
+REDIS_HISTORY_URL = f"redis://{CACHE_HOST}:{CACHE_PORT}/{REDIS_HISTORY_DB}"
+
+def resolve_cert(crt):
+    cert = Path(crt)
+    if not cert.is_absolute():
+        cert = BASE_DIR.joinpath(cert)
+    else:
+        cert.resolve()
+    return cert
+
+if MILVUS_SERVER_CERT:
+    MILVUS_SERVER_CERT = str(resolve_cert(MILVUS_SERVER_CERT))
+if MILVUS_CA_CERT:
+    MILVUS_CA_CERT = str(resolve_cert(MILVUS_CA_CERT))
+if MILVUS_SERVER_KEY:
+    MILVUS_SERVER_KEY = str(resolve_cert(MILVUS_SERVER_KEY))
+
+# QDRANT:
+QDRANT_PROTOCOL = config.get('QDRANT_PROTOCOL', fallback='http')
+QDRANT_HOST = config.get('QDRANT_HOST', fallback='localhost')
+QDRANT_PORT = config.get('QDRANT_PORT', fallback=6333)
+QDRANT_USE_HTTPS = config.getboolean('QDRANT_USE_HTTPS', fallback=False)
+QDRANT_URL = config.get('QDRANT_URL')
+# QDRANT Connection Type: server or cloud
+QDRANT_CONN_TYPE = config.get('QDRANT_CONN_TYPE', fallback='server')
+
+# ChromaDB:
+CHROMADB_HOST = config.get('CHROMADB_HOST', fallback='localhost')
+CHROMADB_PORT = config.get('CHROMADB_PORT', fallback=8000)
+
+# Embedding Device:
+EMBEDDING_DEVICE = config.get('EMBEDDING_DEVICE', fallback='cpu')
+EMBEDDING_DEFAULT_MODEL = config.get(
+    'EMBEDDING_DEFAULT_MODEL',
+    fallback='thenlper/gte-base'
+)
+MAX_VRAM_AVAILABLE = config.get('MAX_VRAM_AVAILABLE', fallback=20000)
+RAM_AVAILABLE = config.get('RAM_AVAILABLE', fallback=819200)
+CUDA_DEFAULT_DEVICE = config.get('CUDA_DEFAULT_DEVICE', fallback='cpu')
+CUDA_DEFAULT_DEVICE_NUMBER = config.getint('CUDA_DEFAULT_DEVICE_NUMBER', fallback=0)
+MAX_BATCH_SIZE = config.get('MAX_BATCH_SIZE', fallback=768)
+
+# Enable Teams Bot:
+ENABLE_AZURE_BOT = config.getboolean('ENABLE_AZURE_BOT', fallback=True)
+
+## Google Services:
+GOOGLE_API_KEY = config.get('GOOGLE_API_KEY')
+### Google Service Credentials:
+GA_SERVICE_ACCOUNT_NAME = config.get('GA_SERVICE_ACCOUNT_NAME', fallback="google.json")
+GA_SERVICE_PATH = config.get('GA_SERVICE_PATH', fallback="env/google/")
+if isinstance(GA_SERVICE_PATH, str):
+    GA_SERVICE_PATH = Path(GA_SERVICE_PATH)
+
+GOOGLE_TTS_SERVICE = config.get(
+    'GOOGLE_TTS_SERVICE',
+    fallback=GA_SERVICE_PATH.joinpath('tts-service.json')
+)
+if isinstance(GOOGLE_TTS_SERVICE, str):
+    GOOGLE_TTS_SERVICE = Path(GOOGLE_TTS_SERVICE)
+if not GOOGLE_TTS_SERVICE.is_absolute():
+    GOOGLE_TTS_SERVICE = BASE_DIR.joinpath(GOOGLE_TTS_SERVICE)
+if not GOOGLE_TTS_SERVICE.exists():
+    GOOGLE_TTS_SERVICE = None
+
+# BASE STATIC:
+BASE_STATIC_URL = config.get(
+    'BASE_STATIC_URL',
+    fallback='http://localhost:5000/static'
+)
+
+# Google SerpAPI:
+SERPAPI_API_KEY = config.get('SERPAPI_API_KEY')
+
+# Groq API Key:
+GROQ_API_KEY = config.get('GROQ_API_KEY')
+
+# Ethical Principle:
+ETHICAL_PRINCIPLE = config.get(
+    'ETHICAL_PRINCIPLE',
+    fallback='The model should only talk about ethical and legal things.'
+)
+
+# Embedding Configuration:
+
+# VERTEX
+VERTEX_PROJECT_ID = config.get('VERTEX_PROJECT_ID')
+VERTEX_REGION = config.get('VERTEX_REGION')
+
+# OpenAI:
+OPENAI_API_KEY = config.get('OPENAI_API_KEY')
+OPENAI_ORGANIZATION = config.get('OPENAI_ORGANIZATION')
+
+## HTTPClioent
+HTTPCLIENT_MAX_SEMAPHORE = config.getint("HTTPCLIENT_MAX_SEMAPHORE", fallback=5)
+HTTPCLIENT_MAX_WORKERS = config.getint("HTTPCLIENT_MAX_WORKERS", fallback=1)
+
+## Google API:
+GOOGLE_API_KEY = config.get('GOOGLE_API_KEY')
+GOOGLE_SEARCH_API_KEY = config.get('GOOGLE_SEARCH_API_KEY')
+GOOGLE_SEARCH_ENGINE_ID = config.get('GOOGLE_SEARCH_ENGINE_ID')
+GOOGLE_PLACES_API_KEY = config.get('GOOGLE_PLACES_API_KEY')
+GOOGLE_CREDENTIALS_FILE = Path(
+    config.get(
+        'GOOGLE_CREDENTIALS_FILE',
+        fallback=BASE_DIR.joinpath('env', 'google', 'key.json')
+    )
+)
+
+## LLM default config:
+DEFAULT_LLM_MODEL = config.get('LLM_MODEL', fallback='gemini-1.5-pro')
+DEFAULT_LLM_TEMPERATURE = config.get('LLM_TEMPERATURE', fallback=0.1)

parrot/crew/__init__.py

@@ -0,0 +1,3 @@
+"""
+NAV Crew is using CrewAI to manage the crew members and their roles.
+"""

parrot/crew/tools/__init__.py

@@ -0,0 +1,22 @@
+"""
+A Directory for adding more Tools to CrewAI
+"""
+from .duckgo import DuckDuckGoRelevantSearch, DuckDuckGoSearchTool
+from .rag import RagSearchTool
+from .file import SaveFile
+from .bing import BingSearchTool
+from .md2pdf import MarkdownToPDFTool
+from .google import GoogleSearchTool, GoogleSiteSearchTool, GoogleLocationFinder
+
+
+__all__ = [
+    'GoogleSearchTool',
+    'GoogleSiteSearchTool',
+    'BingSearchTool',
+    'DuckDuckGoRelevantSearch',
+    'DuckDuckGoSearchTool',
+    'RagSearchTool',
+    'SaveFile',
+    'MarkdownToPDFTool',
+    'GoogleLocationFinder',
+]

parrot/crew/tools/bing.py

@@ -0,0 +1,13 @@
+from langchain_community.utilities.bing_search import BingSearchAPIWrapper
+from crewai_tools import BaseTool
+
+
+class BingSearchTool(BaseTool):
+    """Microsoft Bing Search Tool."""
+    name: str = "Microsoft Bing Search"
+    description: str = "Search the web using Microsoft Bing Search API"
+
+    def _run(self, query: str) -> dict:
+        """Run the Bing Search Tool."""
+        bing = BingSearchAPIWrapper(k=5)
+        return bing.results(query=query, num_results=5)