adding few new folders

Author: duttakapil

adr/README.md

@@ -0,0 +1,77 @@
+# Architecture Decision Records (ADR)
+
+This directory contains Architecture Decision Records (ADRs) documenting significant architectural decisions made in this project.
+
+## What is an ADR?
+
+An Architecture Decision Record is a document that captures an important architectural decision made along with its context and consequences.
+
+## ADR Format
+
+Each ADR follows this format:
+
+```markdown
+# ADR {number}: {title}
+
+## Status
+
+[Proposed | Accepted | Deprecated | Superseded]
+
+## Context
+
+What is the issue that we're seeing that is motivating this decision or change?
+
+## Decision
+
+What is the change that we're proposing and/or doing?
+
+## Consequences
+
+What becomes easier or more difficult to do because of this change?
+```
+
+## List of ADRs
+
+### Project Structure
+
+- [ADR-0001](./0001-modular-pattern-structure.md): Modular Pattern Structure
+- [ADR-0002](./0002-async-first-approach.md): Async-First Approach
+- [ADR-0003](./0003-type-hints-and-validation.md): Type Hints and Validation
+
+### Building Blocks
+
+- [ADR-0004](./0004-llm-provider-abstraction.md): LLM Provider Abstraction
+- [ADR-0005](./0005-tool-integration-framework.md): Tool Integration Framework
+- [ADR-0006](./0006-memory-management.md): Memory Management Strategy
+
+### Workflows
+
+- [ADR-0007](./0007-prompt-chain-design.md): Prompt Chain Design
+- [ADR-0008](./0008-routing-strategy.md): Routing Strategy
+- [ADR-0009](./0009-parallel-execution.md): Parallel Execution Approach
+- [ADR-0010](./0010-orchestration-model.md): Orchestration Model
+- [ADR-0011](./0011-optimization-strategies.md): Optimization Strategies
+
+### Agents
+
+- [ADR-0012](./0012-agent-architecture.md): Agent Architecture
+- [ADR-0013](./0013-domain-specialization.md): Domain Specialization Approach
+
+### Infrastructure
+
+- [ADR-0014](./0014-error-handling.md): Error Handling Strategy
+- [ADR-0015](./0015-logging-approach.md): Logging Approach
+- [ADR-0016](./0016-testing-strategy.md): Testing Strategy
+- [ADR-0017](./0017-configuration-management.md): Configuration Management
+
+## Creating New ADRs
+
+1. Copy the template from `template.md`
+2. Create a new file with the next number in sequence
+3. Fill in the sections
+4. Add a link to this index
+5. Submit for review
+
+## Superseded ADRs
+
+When an ADR is superseded, update its status and add a link to the new ADR that supersedes it.

agents/utils/llm.py

@@ -0,0 +1,142 @@
+"""
+LLM Caller Utility
+
+A utility class for making calls to various LLM APIs with consistent interface.
+"""
+
+import os
+from typing import Dict, List, Optional, Union
+
+import anthropic
+from openai import OpenAI
+from google.cloud import aiplatform
+from azure.ai.ml import MLClient
+
+class LLMCaller:
+    """A utility class for making LLM API calls."""
+    
+    @staticmethod
+    def get_client(provider: str = None):
+        """Get the appropriate LLM client based on environment configuration."""
+        if not provider:
+            # Determine provider based on available API keys
+            if os.getenv("ANTHROPIC_API_KEY"):
+                provider = "anthropic"
+            elif os.getenv("OPENAI_API_KEY"):
+                provider = "openai"
+            elif os.getenv("GOOGLE_APPLICATION_CREDENTIALS"):
+                provider = "google"
+            elif os.getenv("AZURE_OPENAI_API_KEY"):
+                provider = "azure"
+            else:
+                raise ValueError("No LLM API credentials found in environment")
+        
+        if provider == "anthropic":
+            return anthropic.Anthropic()
+        elif provider == "openai":
+            return OpenAI()
+        elif provider == "google":
+            return aiplatform.init()
+        elif provider == "azure":
+            return MLClient.from_config()
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")
+    
+    @staticmethod
+    def get_default_model(provider: str) -> str:
+        """Get the default model for a provider."""
+        defaults = {
+            "anthropic": "claude-3-opus-20240229",
+            "openai": "gpt-4-turbo-preview",
+            "google": "text-bison@002",
+            "azure": "gpt-4"
+        }
+        return os.getenv(f"{provider.upper()}_DEFAULT_MODEL", defaults[provider])
+    
+    @staticmethod
+    async def call(
+        system: str,
+        user: str,
+        provider: str = None,
+        model: str = None,
+        temperature: float = 0.7,
+        max_tokens: int = 1000,
+        stop: Optional[Union[str, List[str]]] = None
+    ) -> str:
+        """
+        Make a call to an LLM API.
+        
+        Args:
+            system: System message/prompt
+            user: User message/prompt
+            provider: LLM provider (anthropic, openai, google, azure)
+            model: Model to use (defaults to provider's default)
+            temperature: Sampling temperature (0.0 to 1.0)
+            max_tokens: Maximum tokens in response
+            stop: Optional stop sequence(s)
+            
+        Returns:
+            The LLM's response text
+        """
+        client = LLMCaller.get_client(provider)
+        provider = provider or ("anthropic" if isinstance(client, anthropic.Anthropic) else
+                              "openai" if isinstance(client, OpenAI) else
+                              "google" if str(client.__class__).startswith("google") else
+                              "azure")
+        
+        model = model or LLMCaller.get_default_model(provider)
+        
+        if provider == "anthropic":
+            response = await client.messages.create(
+                model=model,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                system=system,
+                messages=[{"role": "user", "content": user}],
+                stop_sequences=stop
+            )
+            return response.content[0].text
+            
+        elif provider == "openai":
+            response = await client.chat.completions.create(
+                model=model,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                messages=[
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": user}
+                ],
+                stop=stop
+            )
+            return response.choices[0].message.content
+            
+        elif provider == "google":
+            response = await client.predict_text(
+                model=model,
+                temperature=temperature,
+                max_output_tokens=max_tokens,
+                prompt=f"{system}\n\n{user}",
+                stop_sequences=stop
+            )
+            return response.text
+            
+        elif provider == "azure":
+            response = await client.chat.completions.create(
+                deployment_name=model,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                messages=[
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": user}
+                ],
+                stop=stop
+            )
+            return response.choices[0].message.content
+            
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")
+            
+    @staticmethod
+    def format_prompt(template: str, **kwargs) -> str:
+        """Format a prompt template with variables."""
+        return template.format(**kwargs) 

agents/utils/web.py

@@ -0,0 +1,98 @@
+"""
+Web Utilities
+
+Utilities for web search and webpage content extraction.
+"""
+
+import os
+from typing import Dict, List, Optional
+import aiohttp
+from bs4 import BeautifulSoup
+from duckduckgo_search import AsyncDDGS
+
+from .llm import LLMCaller
+
+class WebSearchTool:
+    """A tool for performing web searches."""
+    
+    def __init__(self, name: str, description: str, parameters: Dict):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        
+    async def __call__(self, query: str, num_results: int = 3) -> Dict:
+        """
+        Perform a web search using DuckDuckGo.
+        
+        Args:
+            query: Search query
+            num_results: Number of results to return
+            
+        Returns:
+            Dict containing search results
+        """
+        async with AsyncDDGS() as ddgs:
+            results = []
+            async for r in ddgs.text(query, max_results=num_results):
+                results.append({
+                    "title": r["title"],
+                    "snippet": r["body"],
+                    "url": r["link"]
+                })
+            return {"results": results}
+
+class WebpageReaderTool:
+    """A tool for reading and extracting content from webpages."""
+    
+    def __init__(self, name: str, description: str, parameters: Dict):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        
+    async def __call__(self, url: str) -> Dict:
+        """
+        Read and extract content from a webpage.
+        
+        Args:
+            url: URL of the webpage to read
+            
+        Returns:
+            Dict containing extracted content and metadata
+        """
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status != 200:
+                    raise ValueError(f"Failed to fetch URL: {url}")
+                    
+                html = await response.text()
+                soup = BeautifulSoup(html, "html.parser")
+                
+                # Remove script and style elements
+                for script in soup(["script", "style"]):
+                    script.decompose()
+                
+                # Extract text content
+                text = soup.get_text()
+                
+                # Clean up whitespace
+                lines = (line.strip() for line in text.splitlines())
+                chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+                text = " ".join(chunk for chunk in chunks if chunk)
+                
+                # Extract metadata
+                title = soup.title.string if soup.title else ""
+                meta_desc = soup.find("meta", attrs={"name": "description"})
+                description = meta_desc["content"] if meta_desc else ""
+                
+                # Use LLM to clean and structure content
+                cleaned_content = await LLMCaller.call(
+                    system="You are a helpful assistant that cleans and structures webpage content.",
+                    user=f"Clean and structure the following webpage content, removing any irrelevant parts like navigation, footers, etc:\n\n{text[:2000]}..."  # Limit content length
+                )
+                
+                return {
+                    "title": title,
+                    "description": description,
+                    "content": cleaned_content,
+                    "url": url
+                }