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

parrot/bots/scraper/templates.py

@@ -0,0 +1,115 @@
+BESTBUY_TEMPLATE = {
+    'search_steps': [
+    {
+        'action': 'navigate',
+        'target': 'https://www.bestbuy.com/?intl=nosplash',
+        'description': 'Best Buy home'
+    },
+    {
+        'action': 'wait',
+        'target': 'presence_of_element_located:textarea[id="autocomplete-search-bar"], input[aria-label*="Search"]',
+        'timeout': 5,
+        'description': 'Wait for Text Area input to be present'
+    },
+    {
+        'action': 'fill',
+        'target': 'textarea[id="autocomplete-search-bar"], input[aria-label*="Search"]',
+        'value': '{search_term}',
+        'description': 'Type product'
+    },
+    {
+        'action': 'click',
+        'target': 'button[id="autocomplete-search-button"], button[aria-label="Search-Button"]',
+        'description': 'Submit search'
+    },
+    {
+        'action': 'wait',
+        'target': '.sku-block',
+        'timeout': 15,
+        'description': 'Wait For Results'
+    }
+    ],
+    'product_selectors': [
+    {
+        'name':'product_titles',
+        'selector': 'h2.product-title',
+        'extract_type':'text',
+        'multiple':True
+    },
+    {
+        'name':'product_prices',
+        'selector': 'div[data-testid="price-block-customer-price"], span',
+        'extract_type':'text',
+        'multiple':True
+    },
+    {
+        'name':'product_links',
+        'selector': '.sku-block-content-title a.product-list-item-link',
+        'extract_type':'attribute',
+        'attribute':'href',
+        'multiple':True
+    }
+    ],
+    'guidance': 'Best Buy uses dynamic loading and specific CSS classes for products. Search results appear in .sku-item-list containers.'
+}
+
+AMAZON_TEMPLATE = {
+    'search_steps': [
+    {'action':'navigate','target':'https://www.amazon.com','description':'Amazon home'},
+    {'action':'wait','target':'#twotabsearchtextbox','timeout':15,'description':'Wait for search box'},
+    {'action':'fill','target':'#twotabsearchtextbox','value':'{search_term}','description':'Type product'},
+    {'action':'click','target':'#nav-search-submit-button','description':'Search'},
+    {'action':'wait','target':'[data-component-type="s-search-result"]','timeout':20,'description':'Wait results'}
+    ],
+    'product_selectors': [
+        {
+            'name': 'product_titles',
+            'selector': '[data-component-type="s-search-result"] h2 a span',
+            'extract_type': 'text',
+            'multiple': True
+        },
+        {
+            'name': 'product_prices',
+            'selector': '.a-price-whole, .a-price .a-offscreen',
+            'extract_type': 'text',
+            'multiple': True
+        }
+    ],
+    'guidance': 'Amazon uses data-component-type attributes for search results. Prices can be in different formats.'
+}
+
+EBAY_TEMPLATE = {
+    'search_steps': [
+        {
+            'action': 'navigate',
+            'target': 'https://www.ebay.com',
+            'description': 'Navigate to eBay homepage'
+        },
+        {
+            'action': 'fill',
+            'target': '#gh-search-input',
+            'value': '{search_term}',
+            'description': 'Fill search input'
+        },
+        {
+            'action': 'click',
+            'target': '#gh-search-btn',
+            'description': 'Click search button'
+        }
+    ],
+    'product_selectors': [
+        {
+            'name': 'product_titles',
+            'selector': '.it-title-lnk',
+            'extract_type': 'text',
+            'multiple': True
+        },
+        {
+            'name': 'product_prices',
+            'selector': '.notranslate',
+            'extract_type': 'text',
+            'multiple': True
+        }
+    ],
+    'guidance': 'eBay search results use .it-title-lnk for titles and .notranslate for prices.'
+}

parrot/bots/stores/__init__.py

@@ -0,0 +1,5 @@
+from .local import LocalKBMixin
+
+__all__ = (
+    'LocalKBMixin',
+)

parrot/bots/stores/local.py

@@ -0,0 +1,172 @@
+"""
+LocalKBMixin: Mixin to add local markdown KB support to agents.
+
+This mixin provides automatic loading of markdown knowledge bases from
+the agent's local directory structure (AGENTS_DIR/<agent_name>/kb/).
+"""
+from typing import Optional, List
+from pathlib import Path
+# from ...stores.kb.local import LocalKB
+from ...conf import AGENTS_DIR
+
+
+class LocalKBMixin:
+    """
+    Mixin to add local markdown KB support to agents.
+
+    Usage:
+        class AbstractBot(DBInterface, LocalKBMixin, ABC):
+            ...
+
+    This mixin provides:
+    - Automatic KB directory detection
+    - Loading of markdown files from AGENTS_DIR/<agent_name>/kb/
+    - Integration with the agent's knowledge_bases list
+    - Proper error handling and logging
+    """
+    def _get_kb_local_files(self, kb_dir: Path) -> List[Path]:
+        """
+        Get list of markdown or text files in KB directory.
+
+        Args:
+            kb_dir: Path to KB directory
+
+        Returns:
+            List[Path]: List of .md or .txt files
+        """
+        if not kb_dir.exists():
+            return []
+
+        return list(kb_dir.glob("*.md")) + list(kb_dir.glob("*.txt"))
+
+    def _get_agent_kb_directory(self) -> Optional[Path]:
+        """
+        Get the kb/ directory for this agent.
+
+        Returns path to AGENTS_DIR/<agent_name|agent_id>/kb/
+        """
+        safe_name = None
+        if hasattr(self, 'agent_id'):
+            safe_name = self.agent_id.lower().replace(' ', '_')
+
+        elif hasattr(self, 'name'):
+            safe_name = self.name.lower().replace(' ', '_')
+        else:
+            return None
+        kb_dir = Path(AGENTS_DIR) / safe_name / 'kb'
+        return kb_dir
+
+    async def configure_local_kb(self) -> None:
+        """
+        Configure local markdown KB for this agent.
+
+        Called automatically during configure().
+        Loads markdown files from AGENTS_DIR/<agent_name>/kb/
+
+        Process:
+        1. Locate agent's KB directory
+        2. Scan for .md files
+        3. Create LocalMarkdownKB instance
+        4. Load and vectorize documents
+        5. Add to agent's knowledge_bases list
+
+        This method fails gracefully - if no KB exists or loading fails,
+        the agent continues without local KB.
+        """
+        kb_dir = self._get_agent_kb_directory()
+
+        print('::: Configuring local KB from directory:', kb_dir)
+
+        if not kb_dir or not kb_dir.exists():
+            self.logger.debug(
+                f":: No local KB directory found at {kb_dir}"
+            )
+            return
+
+        # Check if directory has markdown or text files
+        local_files = self._get_kb_local_files(kb_dir)
+        if not local_files:
+            self.logger.debug(
+                f"No document files found in local KB directory {kb_dir}"
+            )
+            return
+
+        self.logger.notice(
+            f"Loading local KB from {kb_dir} "
+            f"({len(local_files)} document files)"
+        )
+
+        try:
+            # Create LocalKB store
+            from ...stores.kb.local import LocalKB
+            local_kb = LocalKB(
+                name=f"{self.name}_local",
+                kb_directory=kb_dir,
+                category="agent_local",
+                description=f"Local knowledge base for {self.name}",
+                embedding_model=getattr(
+                    self,
+                    'kb_embedding_model',
+                    'sentence-transformers/all-mpnet-base-v2'
+                ),
+                dimension=getattr(self, 'kb_dimension', 384),
+                always_active=True,
+                auto_load=True,
+            )
+
+            # Load documents
+            num_docs = await local_kb.load_documents()
+
+            # Add to knowledge bases list
+            if not hasattr(self, 'knowledge_bases'):
+                self.knowledge_bases = []
+
+            self.knowledge_bases.append(local_kb)
+
+            self.logger.info(
+                f"Local KB loaded: {num_docs} chunks from {len(local_files)} files"
+            )
+
+        except Exception as e:
+            self.logger.error(
+                f"Error loading local KB: {e}",
+                exc_info=True
+            )
+
+    def has_local_kb(self) -> bool:
+        """
+        Check if agent has a local KB loaded.
+
+        Returns:
+            bool: True if local KB is present in knowledge_bases
+        """
+        if not hasattr(self, 'knowledge_bases'):
+            return False
+
+        for kb in self.knowledge_bases:
+            if hasattr(kb, 'category') and kb.category == "agent_local":
+                return True
+
+        return False
+
+    def get_local_kb_info(self) -> Optional[dict]:
+        """
+        Get information about the loaded local KB.
+
+        Returns:
+            Optional[dict]: KB info including name, directory, files count
+        """
+        if not hasattr(self, 'knowledge_bases'):
+            return None
+
+        for kb in self.knowledge_bases:
+            if hasattr(kb, 'category') and kb.category == "agent_local":
+                return {
+                    'name': kb.name,
+                    'directory': str(kb.kb_directory),
+                    'files_loaded': len(kb._loaded_files),
+                    'is_loaded': kb._is_loaded,
+                    'cache_file': str(kb.cache_file)
+                }
+
+        return None

parrot/bots/webdev.py

@@ -0,0 +1,81 @@
+
+from typing import List, Optional
+from pathlib import Path
+from .agent import BasicAgent
+from ..tools.webapp_tool import WebAppGeneratorTool
+from ..tools.abstract import AbstractTool
+
+
+class WebDeveloperAgent(BasicAgent):
+    """
+    Specialized agent for web application development.
+
+    This agent has deep expertise in creating web applications using Streamlit,
+    React, and HTML/JavaScript. It can generate complete, production-ready apps
+    based on natural language descriptions.
+    """
+
+    def __init__(
+        self,
+        name: str = 'WebDeveloper',
+        agent_id: str = 'webdev',
+        use_llm: str = 'google',
+        output_dir: Optional[Path] = None,
+        **kwargs
+    ):
+        """
+        Initialize the WebDeveloper Agent.
+
+        Args:
+            name: Agent name
+            agent_id: Unique agent identifier
+            use_llm: LLM provider to use
+            output_dir: Directory for saving generated apps
+            **kwargs: Additional arguments
+        """
+        self.output_dir = output_dir or Path('./generated_apps')
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        super().__init__(
+            name=name,
+            agent_id=agent_id,
+            use_llm=use_llm,
+            system_prompt=self._get_system_prompt(),
+            **kwargs
+        )
+
+    def agent_tools(self) -> List[AbstractTool]:
+        """Return web development specific tools."""
+        return [
+            WebAppGeneratorTool(
+                llm_client=self.llm,
+                output_dir=self.output_dir,
+                default_type='streamlit'
+            )
+        ]
+
+    def _get_system_prompt(self) -> str:
+        """Return the specialized system prompt for web development."""
+        return """You are an expert full-stack web developer specializing in rapid application development.
+
+Your expertise includes:
+- Building data-driven applications with Streamlit
+- Creating modern single-page applications with React
+- Developing standalone web pages with HTML/CSS/JavaScript
+- UI/UX design and responsive layouts
+- Data visualization and interactive dashboards
+
+When users ask you to create applications:
+1. Ask clarifying questions about requirements if needed
+2. Choose the most appropriate technology (Streamlit for data apps, React for complex UIs, HTML for simple pages)
+3. Use the web_app_generator tool to create the application
+4. Explain the generated code and how to run/deploy it
+5. Offer to make modifications or improvements
+
+Always generate production-ready, well-structured code with:
+- Clear documentation and comments
+- Proper error handling
+- Responsive design
+- Accessibility considerations
+- Modern best practices
+
+Be conversational and helpful. Guide users through the development process."""

parrot/cli.py

@@ -0,0 +1,17 @@
+"""Top-level CLI entrypoint for Parrot utilities."""
+import click
+from parrot.mcp.cli import mcp
+
+
+@click.group()
+def cli():
+    """Parrot command-line interface."""
+    pass
+
+
+# Attach subcommands
+cli.add_command(mcp, name="mcp")
+
+
+if __name__ == "__main__":
+    cli()

parrot/clients/__init__.py

@@ -0,0 +1,16 @@
+"""
+Client for Interactions with LLMs (Language Models)
+This module provides a client interface for interacting with various LLMs.
+It includes functionality for sending requests, receiving responses, and handling errors.
+"""
+from .base import (
+    AbstractClient,
+    LLM_PRESETS,
+    StreamingRetryConfig
+)
+
+__all__ = (
+    "AbstractClient",
+    "LLM_PRESETS",
+    "StreamingRetryConfig"
+)