Intial Files

.env.example

@@ -0,0 +1,5 @@
+# Google API Key
+# Get your key from: https://aistudio.google.com/apikey
+GOOGLE_API_KEY=your_google_api_key_here
+OPENROUTER_API_KEY=your_openrouter_api_key_here
+PINECONE_API_KEY=your_pinecone_api_key_here

.gitignore

@@ -0,0 +1,76 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environments
+venv/
+ENV/
+env/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Environment Variables
+.env
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+*.log
+
+#json
+*.evalset.json
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Playwright browsers cache (optional - can be removed if needed)
+# ms-playwright/
+
+# Crawl4AI cache
+.crawl4ai/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Development/Debug files
+verify_*.py
+debug_*.py
+inspect_*.py
+test_*.py
+PROJECT_RENAME_SUMMARY.md
+
+# Old database files
+legacy_solver.db

CONTRIBUTING.md

@@ -0,0 +1,52 @@
+# Contributing to AI-Powered Package Conflict Resolver
+
+Thank you for your interest in contributing! 🎉
+
+## Getting Started
+
+1. Fork the repository
+2. Clone your fork: `git clone https://github.com/your-username/package_conflict_resolver.git`
+3. Create a feature branch: `git checkout -b feature/amazing-feature`
+4. Make your changes
+5. Commit your changes: `git commit -m 'Add amazing feature'`
+6. Push to the branch: `git push origin feature/amazing-feature`
+7. Open a Pull Request
+
+## Development Setup
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Install browsers
+crawl4ai-setup
+
+# Set up environment
+cp .env.example .env
+# Add your GOOGLE_API_KEY
+```
+
+## Code Style
+
+- Follow PEP 8 guidelines
+- Use type hints where appropriate
+- Add docstrings to functions and classes
+- Keep functions focused and modular
+
+## Testing
+
+Before submitting a PR:
+1. Test your changes with `python main.py`
+2. Ensure no errors in the web interface: `adk web web_app.py --no-reload`
+
+## Reporting Issues
+
+When reporting issues, please include:
+- Python version
+- Operating system
+- Error message (full stack trace)
+- Steps to reproduce
+
+## Questions?
+
+Feel free to open an issue for any questions or discussions!

Dockerfile

@@ -0,0 +1,37 @@
+# Use Python 3.11 to avoid the deprecation warning
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PORT=7860
+
+# Install system dependencies (including those for Playwright/Crawl4AI if needed)
+# We install basic build tools and libraries often needed by python packages
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Playwright browsers (required by crawl4ai)
+RUN playwright install --with-deps chromium
+
+# Copy the rest of the application
+COPY . .
+
+# Expose the port (Hugging Face Spaces use 7860)
+EXPOSE 7860
+
+# Run the application
+# We point to 'src' because we created src/agent.py
+CMD ["adk", "web", "--host", "0.0.0.0", "--port", "7860", "src"]

KAGGLE_CAPSTONE_WRITEUP.md

@@ -0,0 +1,121 @@
+# Package Conflict Identifier 📦🔍
+**Why "Chatting with AI" Isn't Enough for Modern Debugging**
+
+---
+
+## The Problem: "Lazy AI" vs. Real-World Bugs
+
+We've all been there. You paste a cryptic error message into ChatGPT or Gemini, and it gives you a confident, generic answer: *"Check your syntax"* or *"Ensure your JSON is formatted correctly."*
+
+But what if your syntax is fine? What if the error isn't in *your* code, but deep inside a library you just installed? What if it's a brand-new bug reported on GitHub only 48 hours ago?
+
+**Static LLMs fail here because they are frozen in time.** They don't know about the bug report filed yesterday. They don't know that `library-v2.1` broke compatibility with `framework-v3.0`. They guess based on general patterns, often leading you down a rabbit hole of useless "fixes."
+
+I built the **Package Conflict Identifier** to solve this. It doesn't just "guess"—it **investigates**.
+
+---
+
+## The "Real Web" Advantage
+
+This isn't just a chatbot. It's an autonomous research team. When it sees an error, it doesn't rely solely on its training data. It:
+1.  **Diagnoses** the specific package causing the issue.
+2.  **Searches** the live web for that specific error string.
+3.  **Crawls** GitHub Issues, StackOverflow, and official documentation.
+4.  **Synthesizes** a solution based on *current* reality, not 2023 data.
+
+### Case Study: The "Ollama/LiteLLM" Bug
+
+During development, I encountered a nasty error while trying to chain agents using **LiteLLM** and **Ollama**:
+
+```text
+litellm.APIConnectionError: Ollama_chatException - {"error":"json: cannot unmarshal array into Go struct field ChatRequest.messages.content of type string"}
+```
+
+#### ❌ The Generic AI Answer (ChatGPT/Gemini)
+When I pasted this into a standard LLM, it said:
+> *"You are sending an array instead of a string in your JSON request. Change your code to send a string."*
+
+This was **useless**. I wasn't writing the raw JSON request; the `litellm` library was. I couldn't "just change my code."
+
+#### ✅ The Agent's Answer
+My **Package Conflict Identifier** took a different approach.
+1.  **Query Creator** generated search terms: `"LiteLLM Ollama json unmarshal array error"`.
+2.  **Docs Search Agent** found a specific GitHub Issue: **`BerriAI/litellm#11148`**.
+3.  **Web Crawl Agent** read the issue thread and found the root cause:
+    > *"LiteLLM sends content as an array/object (OpenAI-style), but Ollama expects a simple string. This is a known incompatibility in LiteLLM v1.66+."*
+
+**The Result:** Instead of wasting hours debugging my own code, the agent told me: *"This is a bug in the library. Downgrade LiteLLM or apply this specific patch."*
+
+**This is the difference between a chatbot and an engineer.**
+
+---
+
+## System Architecture
+
+How does it work? It uses a multi-agent pipeline to mimic a senior engineer's debugging workflow.
+
+```text
+User Input (Error Log)
+      |
+      V
++----------------------------------+
+| PHASE 1: DIAGNOSIS               |
+| Query Creator Agent              |
+| (Consults Pinecone Memory)       |
++----------------------------------+
+      |
+      V
++----------------------------------+
+| PHASE 2: RESEARCH                |
+| Parallel Research Team:          |
+| 1. Docs Search Agent             |
+| 2. Community Search Agent        |
+| 3. Web Crawl Agent (Firecrawl)   |
++----------------------------------+
+      |
+      V
++----------------------------------+
+| PHASE 3: REPAIR                  |
+| Code Surgeon Team:               |
+| [Surgeon] -> [Verify] -> [Fix]   |
++----------------------------------+
+      |
+      V
+Output (Fixed requirements.txt)
+```
+
+### Detailed Component Breakdown
+
+#### 1. Phase 1: Contextual Diagnosis (The Detective)
+The entry point is the **Query Creator Agent**, powered by **Gemini 2.0 Flash Lite**. We chose Flash Lite for its speed and low latency. This agent also has access to **Pinecone Vector Memory**. Before searching the web, it queries the vector database: *"Have we seen this error before?"* This "Long-Term Memory" allows the system to get smarter over time, instantly recalling fixes for recurring issues without re-doing the research.
+
+#### 2. Phase 2: The Parallel Research Engine (The Researchers)
+Research is time-consuming. To optimize this, we use the **ParallelAgent** pattern. Two agents run simultaneously:
+*   **Docs Search Agent**: Uses Google Search API restricted to domains like `readthedocs.io`, `docs.python.org`, and `pypi.org`. It looks for the "official" way things should work.
+*   **Community Search Agent**: Restricted to `stackoverflow.com` and `github.com/issues`. It looks for the "hacky" workarounds and bug reports.
+
+#### 3. Phase 3: Deep Web Extraction (The Crawler)
+Standard search tools only give you snippets. To truly understand a bug, you need to read the code. We integrated **Firecrawl**, a specialized tool for turning websites into LLM-ready markdown. When the researchers find a promising URL (like a GitHub commit diff), the **Web Crawl Agent** (powered by **Grok** via OpenRouter) visits the page, renders the JavaScript, and extracts the raw text. Grok was chosen here for its massive context window (128k+ tokens), allowing it to ingest entire documentation pages in one go.
+
+#### 4. Phase 4: The Self-Correcting Loop (The Surgeon)
+The final phase is the **Code Surgeon**. It proposes a fix (e.g., a new `requirements.txt`). But instead of just outputting it, it enters a **Validation Loop**.
+1.  **Surgeon** generates the file.
+2.  **Verification Agent** (a separate model instance) acts as a "Linter." It checks: *Does this version exist? Are there obvious conflicts?*
+3.  If the check fails, the Surgeon is reprimanded and forced to try again.
+This "System 2 Thinking" loop significantly reduces the rate of hallucinated package versions.
+
+---
+
+## Technology Stack
+
+*   **Orchestration**: Google Agent Development Kit (ADK)
+*   **Reasoning**: Google Gemini 2.0 Flash Lite (Speed) & Grok (Context)
+*   **Web Intelligence**: Firecrawl (Deep Scraping) & Google Search API
+*   **Memory**: Pinecone (Long-term Vector Storage) & SQLite (Session History)
+
+## Conclusion
+
+The future of coding isn't just "auto-complete." It's **auto-debug**. By giving LLMs access to the live web and structuring them into specialized agents, we can solve the complex, library-internal bugs that generic chatbots simply can't touch.
+
+**GitHub**: [https://github.com/Yashwant00CR7/AI-Powered-Package-Conflict-Resolver]
+**Built with**: Google ADK, Gemini, Grok, Firecrawl

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Legacy Dependency Solver Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,117 @@
----
-title: AI Package Doctor
-emoji: 🐠
-colorFrom: pink
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Package Conflict Identifier 📦🔍
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Google ADK](https://img.shields.io/badge/Google-ADK-4285F4.svg)](https://github.com/google/adk)
+
+> AI-powered package conflict identifier and resolver using Google's Agent Development Kit (ADK). It leverages a multi-agent architecture with Google Gemini and OpenRouter (Grok) models to diagnose dependency issues, research solutions, and generate fixed configuration files.
+
+## 🎯 Features
+
+- **Advanced Multi-Agent Architecture**:
+  - **Context Search Agent**: Retrieves insights from past sessions using Pinecone vector memory.
+  - **Parallel Research Team**: Concurrent searching of Official Docs and Community forums.
+  - **Web Crawl Agent**: Uses **Firecrawl** (via OpenRouter) for deep web scraping of documentation.
+  - **Code Surgeon**: Generates and validates `requirements.txt` fixes.
+- **Hybrid Model Intelligence**:
+  - **Google Gemini 2.0 Flash Lite**: For high-speed reasoning and orchestration.
+  - **Grok 4.1 Fast (via OpenRouter)**: For specialized web crawling and context analysis.
+- **Persistent Memory**:
+  - **Short-Term**: SQLite/PostgreSQL session storage.
+  - **Long-Term**: Pinecone Vector Database for recalling past solutions.
+- **Intelligent Tooling**:
+  - `retrieve_memory`: Semantic search of previous conversations.
+  - `google_search`: Live web search.
+  - `firecrawl`: Advanced web scraping.
+
+## 📁 Project Structure
+
+```
+package_conflict_resolver/
+├── .env                  # Environment variables (API Keys)
+├── requirements.txt      # Dependencies
+├── main.py               # CLI Entry Point
+├── web_app.py            # Web UI Entry Point (ADK Web Server)
+└── src/
+    ├── __init__.py
+    ├── config.py         # Configuration & Service Initialization
+    ├── tools.py          # Custom Tools (Search, Memory, Validation)
+    ├── agents.py         # Agent Definitions & Workflow
+    └── utils.py          # Logging & Helpers
+```
+
+## 🚀 Quick Start
+
+### 1. Clone & Install
+```bash
+git clone <your-repo-url>
+cd package_conflict_resolver
+pip install -r requirements.txt
+```
+
+### 2. Configure Environment
+Create a `.env` file with your API keys:
+```env
+GOOGLE_API_KEY=your_gemini_key
+OPENROUTER_API_KEY=your_openrouter_key
+PINECONE_API_KEY=your_pinecone_key
+DATABASE_URL=sqlite+aiosqlite:///legacy_solver.db
+```
+
+### 3. Run the Agent
+
+**Option A: CLI Mode (Recommended for quick tasks)**
+```bash
+python main.py
+```
+
+**Option B: Web UI (Full Experience)**
+```bash
+adk web --no-reload
+```
+Open [http://127.0.0.1:8000/dev-ui/](http://127.0.0.1:8000/dev-ui/) to interact with the agent visually and view chat history.
+
+## 🤖 Agent Workflow
+
+1.  **Query Creator Agent**:
+    - Analyzes the user's error message.
+    - Uses `retrieve_memory` to check if this issue was solved before.
+    - Generates search queries for the research team.
+
+2.  **Context Search Agent**:
+    - Specifically looks for relevant context in the project's long-term memory.
+
+3.  **Parallel Research Team**:
+    - **Docs Search Agent**: Searches official documentation.
+    - **Community Search Agent**: Searches StackOverflow/GitHub.
+    - **Web Crawl Agent**: Deep crawls specific documentation pages using Firecrawl.
+
+4.  **Code Surgeon**:
+    - Synthesizes all gathered information.
+    - Generates a corrected `requirements.txt` or solution plan.
+
+## ☁️ Deployment & Persistence
+
+### Database
+For production (e.g., Hugging Face Spaces), use a PostgreSQL database:
+```env
+DATABASE_URL=postgresql+asyncpg://user:password@host/dbname
+```
+
+### Long-Term Memory (Pinecone)
+To enable persistent memory across restarts:
+1.  Get a free API key from [Pinecone.io](https://www.pinecone.io).
+2.  Set `PINECONE_API_KEY` in `.env`.
+3.  The agent will automatically index and retrieve past sessions.
+
+## 📝 License
+
+MIT License.
+
+## 🙏 Credits
+
+Built with:
+- [Google Agent Development Kit (ADK)](https://github.com/google/adk)
+- [Google Gemini](https://deepmind.google/technologies/gemini/)
+- [OpenRouter](https://openrouter.ai/)
+- [Pinecone](https://www.pinecone.io/)

main.py

@@ -0,0 +1,143 @@
+"""
+Main entry point for the AI-Powered Package Conflict Resolver.
+Initializes and runs the agent with a test query.
+"""
+import asyncio
+import os
+import nest_asyncio
+from google.adk import Runner
+from google.genai import types
+from src.config import get_session_service
+from src.agents import create_root_agent
+from src.utils import logger
+
+# Apply nest_asyncio to handle event loop conflicts
+nest_asyncio.apply()
+
+
+async def run_session(runner, user_input: str, session_id: str):
+    """
+    Runs an agent session with the given input.
+    
+    Args:
+        runner: The Runner instance
+        user_input: User's query/request
+        session_id: Session identifier for state tracking
+    """
+    logger.info(f"🚀 Starting session: {session_id}")
+    logger.info(f"📝 User input: {user_input}")
+    
+    # Create structured message
+    user_msg = types.Content(
+        role="user",
+        parts=[types.Part.from_text(text=user_input)]
+    )
+    
+    # Run the agent
+    response_generator = runner.run(
+        session_id=session_id,
+        user_id="default_user",
+        new_message=user_msg
+    )
+    
+    # Collect and display response
+    full_response = ""
+    print("\n🤖 Agent Response:\n")
+    for event in response_generator:
+        # ADK events have .content.parts structure
+        if hasattr(event, 'content') and event.content and hasattr(event.content, 'parts'):
+            if event.content.parts:
+                text = event.content.parts[0].text
+                # Filter out empty or "None" responses
+                if text and text != "None":
+                    print(text, end='', flush=True)
+                    full_response += text
+        # Fallback for simple text
+        elif hasattr(event, 'text'):
+            text = event.text
+            print(text, end='', flush=True)
+            full_response += text
+        elif isinstance(event, str):
+            print(event, end='', flush=True)
+            full_response += event
+    
+    print("\n")
+    logger.info(f"✅ Session completed: {session_id}")
+    return full_response
+
+
+async def main():
+    """Main execution function."""
+    logger.info("=" * 60)
+    logger.info("🤖 AI-Powered Package Conflict Resolver - Starting...")
+    logger.info("=" * 60)
+    
+    # Initialize session service
+    session_service = get_session_service()
+    
+    # Create root agent
+    root_agent = create_root_agent()
+    
+    # Initialize runner
+    runner = Runner(
+        agent=root_agent,
+        app_name="package_conflict_resolver",
+        session_service=session_service
+    )
+    logger.info("✅ Runner initialized")
+    
+    # Test query
+    test_query = """
+    I have a legacy Python project with the following dependencies in requirements.txt:
+    
+    pydantic==1.10.2
+    fastapi==0.95.0
+    
+    I'm getting deprecation warnings about regex patterns in Pydantic. 
+    Can you help me fix this and update to compatible versions?
+    """
+    
+    logger.info("\n" + "=" * 60)
+    logger.info("🧪 Running test query...")
+    logger.info("=" * 60 + "\n")
+    
+    # Explicitly create the session first to avoid "Session not found" error
+    # Delete existing DB to ensure clean state
+    if os.path.exists("package_conflict_resolver.db"):
+        try:
+            os.remove("package_conflict_resolver.db")
+            logger.info("🗑️  Removed existing database file")
+        except Exception as e:
+            logger.warning(f"⚠️  Could not remove DB: {e}")
+
+    session_id = "test_session_001"
+    try:
+        # Pass app_name to ensure Runner finds it
+        await session_service.create_session(
+            session_id=session_id, 
+            user_id="default_user",
+            app_name="package_conflict_resolver"
+        )
+        logger.info(f"✅ Created new session: {session_id}")
+    except Exception as e:
+        logger.warning(f"⚠️  Session creation note: {e}")
+
+    # Run the session
+    response = await run_session(
+        runner=runner,
+        user_input=test_query,
+        session_id=session_id
+    )
+    
+    logger.info("\n" + "=" * 60)
+    logger.info("🎉 Test completed successfully!")
+    logger.info("=" * 60)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("\n👋 Interrupted by user")
+    except Exception as e:
+        logger.error(f"❌ Error: {e}", exc_info=True)

requirements.txt

@@ -0,0 +1,11 @@
+google-adk
+crawl4ai
+aiosqlite
+sqlalchemy
+nest_asyncio
+python-dotenv
+certifi
+litellm
+pinecone
+sentence-transformers
+uvicorn

src/__init__.py

@@ -0,0 +1,10 @@
+"""Legacy Dependency Solver - Modular Package"""
+
+from .agents import root_agent
+from .config import get_session_service, get_memory_service
+
+# Initialize services for ADK to discover
+session_service = get_session_service()
+memory_service = get_memory_service()
+
+__all__ = ["root_agent", "session_service", "memory_service"]

src/agent.py

@@ -0,0 +1 @@
+from .agents import agent

src/agents.py

@@ -0,0 +1,323 @@
+"""
+Agent definitions for the AI-Powered Package Conflict Resolver.
+Defines Query Creator, Web Search, Web Crawl, and CodeSurgeon agents.
+"""
+import sys
+import asyncio
+import json
+
+# Fix for Playwright on Windows (NotImplementedError in subprocess)
+if sys.platform == 'win32':
+    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+
+from google.adk import Agent
+from google.adk.agents import SequentialAgent, ParallelAgent
+# from google.adk.events import Event, EventActions # Unused after removing loop
+from google.adk.tools import google_search, load_memory
+from .config import get_model, get_gemini_model
+from .tools import batch_tool, adaptive_tool, save_context_tool, retrieve_context_tool, submit_queries_tool, validate_tool, retrieve_memory_tool
+from .utils import logger
+
+
+def create_query_creator_agent():
+    """
+    Creates the Query Creator agent (Dependency Detective).
+    Generates search queries based on the user's problem.
+    """
+    agent = Agent(
+        name="Query_Creator_Agent",
+        model=get_gemini_model(),
+        tools=[google_search, retrieve_memory_tool], # Added retrieve_memory_tool
+        description="Dependency Detective specialized in diagnosing Python environment conflicts",
+        instruction="""
+        You are the "Dependency Detective," an expert AI agent specialized in diagnosing Python environment conflicts, legacy code rot, and version mismatch errors.
+        Use Google Search Tool if You don't Know about those issue or packages.
+        Use `retrieve_memory` to recall details from previous conversations if the user refers to "last time" or "previous error".
+
+        YOUR GOAL:
+        1. Analyze the input to identify the specific packages involved (e.g., "tensorflow", "numpy").
+        2. Save these package names to the session state using `save_context('packages', 'package1, package2')`.
+        3. Generate a list of targeted, technical search queries that will help a downstream "Web Crawler" find the exact solution.
+
+        INPUT YOU WILL RECEIVE:
+        1. A list of packages (e.g., "tensorflow, keras, numpy").
+        2. An error log or description (e.g., "int32 and float mismatch").
+
+        YOUR ANALYSIS PROCESS:
+        1. Extract the package names and versions from the input.
+        2. Call `save_context('packages', 'extracted_package_list')`.
+        3. Analyze the Error: Is it a syntax error or a compatibility error? Look for keywords like "deprecated", "mismatch", "attribute error".
+        4. Analyze the Stack: Look at the libraries involved.
+        5. Hypothesize Conflicts: Generate search queries that target:
+           - "Breaking changes" in the libraries mentioned.
+           - "Migration guides" for the specific error.
+           - "Compatibility matrices" for the package combinations.
+
+        OUTPUT FORMAT:
+        Start your response with:
+        **Model: Gemini 2.0 Flash Lite**
+        ## Search Queries
+        
+        Return a raw JSON list of strings in your text response.
+        Example: ["numpy.float deprecated version", "tensorflow 2.x keras version incompatibility"]
+        """
+    )
+    logger.info("✅ Query Creator agent created")
+    return agent
+
+
+def create_docs_search_agent():
+    """
+    Creates the Docs Search agent (Official Documentation).
+    """
+    agent = Agent(
+        name="Docs_Search_Agent",
+        model=get_gemini_model(),
+        tools=[google_search],
+        description="Search agent focused on official documentation",
+        instruction="""
+        You are the "Official Docs Researcher".
+        
+        YOUR GOAL:
+        Search for official documentation, API references, and migration guides.
+        Focus on domains like *.org, *.io, *.dev, and official GitHub repositories.
+        
+        INPUT: List of search queries.
+        OUTPUT: Top 4 most relevant OFFICIAL URLs.
+        
+        OUTPUT FORMAT:
+        **Model: Gemini 2.5 Pro**
+        ## Official Docs Results
+        {"top_urls": ["url1", "url2", ...]}
+        """
+    )
+    logger.info("✅ Docs Search agent created")
+    return agent
+
+def create_community_search_agent():
+    """
+    Creates the Community Search agent (StackOverflow, GitHub Issues).
+    """
+    agent = Agent(
+        name="Community_Search_Agent",
+        model=get_gemini_model(),
+        tools=[google_search],
+        description="Search agent focused on community discussions",
+        instruction="""
+        You are the "Community Researcher".
+        
+        YOUR GOAL:
+        Search for community discussions, bug reports, and stackoverflow threads.
+        Focus on sites like stackoverflow.com, github.com/issues, reddit.com.
+        
+        INPUT: List of search queries.
+        OUTPUT: Top 4 most relevant COMMUNITY URLs.
+        
+        OUTPUT FORMAT:
+        **Model: Gemini 2.5 Pro**
+        ## Community Results
+        {"top_urls": ["url1", "url2", ...]}
+        """
+    )
+    logger.info("✅ Community Search agent created")
+    return agent
+
+def create_context_search_agent():
+    """
+    Creates the Context Search agent (General Context).
+    """
+    agent = Agent(
+        name="Context_Search_Agent",
+        model=get_gemini_model(),
+        tools=[google_search],
+        description="Search agent focused on general context and main URL",
+        instruction="""
+        You are the "Context Researcher".
+        
+        YOUR GOAL:
+        1. Analyze the input search queries to identify the "Main Topic" or "Core Library/Framework" (e.g., if input is "numpy float error", main topic is "numpy").
+        2. Search for the Home Page, Main Documentation Hub, or Wikipedia page for this Main Topic.
+        3. Provide the top 3-4 most authoritative URLs for this topic.
+        
+        INPUT: List of search queries.
+        OUTPUT: Top 3-4 most relevant URLs.
+        
+        OUTPUT FORMAT:
+        **Model: Gemini 2.5 Pro**
+        ## Context Results
+        {"top_urls": ["url1", "url2", "url3"]}
+        """
+    )
+    logger.info("✅ Context Search agent created")
+    return agent
+
+
+class WebCrawlAgent(Agent):
+    """
+    Custom Agent for Web Crawling that deterministically tries batch crawl first,
+    then falls back to adaptive crawl if needed.
+    """
+    def __init__(self, model, tools, **kwargs):
+        super().__init__(model=model, tools=tools, **kwargs)
+        
+    async def run(self, input_str: str, **kwargs):
+        """
+        Custom run logic:
+        1. Parse input to get URLs.
+        2. Try batch_crawl_tool.
+        3. Check results.
+        4. If poor results, try adaptive_crawl_tool.
+        """
+        logger.info(f"🕷️ WebCrawlAgent received input: {input_str}")
+        
+        # Simple heuristic to extract URLs (assuming input is JSON or list-like string)
+        # In a real scenario, we might use the LLM to parse it first if it's unstructured.
+        # For now, we'll assume the previous agent passed a list of URLs or we can regex them.
+        import re
+        urls = re.findall(r'https?://[^\s<>"]+|www\.[^\s<>"]+', input_str)
+        
+        if not urls:
+            return "No URLs found to crawl."
+            
+        # 1. Try Batch Crawl
+        logger.info(f"🕷️ Attempting Batch Crawl for {len(urls)} URLs")
+        batch_result = await batch_crawl_tool.func(urls)
+        
+        # 2. Analyze Result (Simple Heuristic)
+        # Check if we got valid content
+        content = batch_result.get("combined_content", "")
+        
+        # If result contains many "Error" or is very short, we might need adaptive
+        if "Error" not in content and len(content) > 500:
+             return f"**Model: Custom Logic**\n## Crawled Content Analysis\n\n{content}"
+             
+        # 3. Fallback to Adaptive (if batch failed significantly)
+        logger.info("⚠️ Batch crawl had issues. Falling back to Adaptive Crawl for first URL...")
+        # For simplicity in this custom agent, we just try the first URL adaptively as a fallback
+        adaptive_result = await adaptive_tool.func(urls[0], query="dependency conflicts version requirements")
+        
+        # Format adaptive result (it's a dict)
+        formatted_adaptive = json.dumps(adaptive_result, indent=2) if isinstance(adaptive_result, dict) else str(adaptive_result)
+        
+        return f"**Model: Custom Logic (Adaptive Fallback)**\n## Crawled Content Analysis\n\n{formatted_adaptive}"
+
+def create_web_crawl_agent():
+    """
+    Creates the Web Crawl agent (Content Extractor).
+    Now uses the Custom WebCrawlAgent class.
+    """
+    agent = WebCrawlAgent(
+        name="Web_Crawl_Agent",
+        model=get_model(),
+        tools=[batch_tool, adaptive_tool],
+        description="Technical Content Extractor using Deterministic Logic",
+        instruction="""
+        You are the "Technical Content Extractor".
+        
+        (Note: This instruction is less critical now as the custom run method handles the logic,
+        but kept for metadata purposes).
+        """
+    )
+    logger.info("✅ Web Crawl agent created (Custom Class)")
+    return agent
+
+
+def create_code_surgeon_agent():
+    """
+    Creates the CodeSurgeon agent that fixes dependency issues.
+    """
+    agent = Agent(
+        name="Code_Surgeon_Agent",
+        model=get_model(),
+        tools=[retrieve_context_tool, save_context_tool],
+        description="Expert Python developer specialized in dependency resolution",
+        instruction="""
+        You are the "Code Surgeon".
+
+        YOUR TASK:
+        1. Use 'retrieve_context' to get the 'packages' and 'versions' stored by the Query Creator.
+        2. Analyze the dependency conflicts provided by the user.
+        3. Based on the research findings from the Web Crawl Agent, determine the correct versions.
+        3. Generate a clean requirements.txt with resolved dependencies.
+        4. Provide an explanation of what was fixed and why.
+
+        OUTPUT FORMAT:
+        - Clear explanation of the issue
+        - Updated requirements.txt content
+        - Migration notes (if breaking changes exist)
+        
+        IMPORTANT:
+        - Call `save_context('solution', 'YOUR_SOLUTION_SUMMARY')` to store the final resolution.
+        - Call `save_context('requirements', 'YOUR_REQUIREMENTS_CONTENT')` to store the file content.
+        """
+    )
+    logger.info("✅ Code Surgeon agent created")
+    return agent
+
+
+# ===== MEMORY SERVICE =====
+from .config import get_memory_service
+global_memory_service = get_memory_service()
+
+# ===== MEMORY CALLBACK =====
+async def auto_save_to_memory(callback_context):
+    """Automatically save session to memory after each agent turn."""
+    try:
+        # Use global memory service instead of context-bound one
+        await global_memory_service.add_session_to_memory(
+            callback_context._invocation_context.session
+        )
+        logger.info("💾 Session automatically saved to memory (Global Service).")
+    except Exception as e:
+        logger.error(f"❌ Failed to auto-save session: {e}")
+
+
+def create_root_agent():
+    """
+    Creates the root agent that orchestrates the sub-agents.
+    """
+    # Create sub-agents
+    query_creator = create_query_creator_agent()
+    # load_memory removed due to model limitations
+    
+    docs_search = create_docs_search_agent()
+    community_search = create_community_search_agent()
+    context_search = create_context_search_agent()
+    
+    # Parallel Research
+    parallel_search = ParallelAgent(
+        name="Parallel_Search_Team",
+        sub_agents=[docs_search, community_search, context_search],
+        description="Parallel search for official, community, and general context resources"
+    )
+    
+    # Group Research Team
+    web_research_team = SequentialAgent(
+        name="Web_Research_Team",
+        sub_agents=[query_creator, parallel_search],
+        description="Team responsible for researching dependency issues"
+    )
+    
+    web_crawl = create_web_crawl_agent()
+    web_crawl = create_web_crawl_agent()
+    
+    # Code Surgeon (No Loop)
+    code_surgeon = create_code_surgeon_agent()
+    
+    # Create the sequential agent
+    agent = SequentialAgent(
+        name="Package_Conflict_Resolver_Root_Agent",
+        sub_agents=[web_research_team, web_crawl, code_surgeon],
+        description="Root agent managing the dependency resolution pipeline",
+        after_agent_callback=auto_save_to_memory # Auto-save history
+    )
+    logger.info("✅ Root agent created with sequential flow (Research Team -> Crawl -> Surgeon)")
+    return agent
+
+
+# ===== MODULE-LEVEL INITIALIZATION FOR ADK WEB =====
+root_agent = create_root_agent()
+
+# Removed App definition to avoid ImportError. 
+# Memory is handled via global_memory_service in callback.
+agent = root_agent

src/app.py

@@ -0,0 +1,23 @@
+"""
+App definition for the AI-Powered Package Conflict Resolver.
+Includes Events Compaction configuration.
+"""
+from google.adk import App
+from google.adk.types import EventsCompactionConfig
+from .agents import root_agent
+from .utils import logger
+from .config import get_memory_service, get_session_service
+
+# Define the App with Events Compaction and Custom Services
+package_conflict_resolver_app = App(
+    name="Package_Conflict_Resolver_App",
+    root_agent=root_agent,
+    memory_service=get_memory_service(),
+    session_service=get_session_service(),
+    events_compaction_config=EventsCompactionConfig(
+        compaction_interval=3,  # Trigger compaction every 3 invocations
+        overlap_size=1,         # Keep 1 previous turn for context
+    ),
+)
+
+logger.info("✅ Package Conflict Resolver App created with Events Compaction (Interval: 3, Overlap: 1)")

src/config.py

@@ -0,0 +1,91 @@
+"""
+Configuration module for model initialization and environment setup.
+CRITICAL: Includes Ollama integration fix for Google ADK.
+"""
+import os
+from dotenv import load_dotenv
+from google.adk.models.lite_llm import LiteLlm
+from google.adk.sessions import DatabaseSessionService
+from google.genai import types
+from .utils import logger
+
+# Load environment variables
+load_dotenv()
+
+# ===== SSL CONFIGURATION =====
+# Fix for SSL certificate errors on Windows
+import certifi
+os.environ['SSL_CERT_FILE'] = certifi.where()
+logger.info(f"🔐 SSL Cert File configured: {os.environ['SSL_CERT_FILE']}")
+
+# ===== MODEL INITIALIZATION =====
+# Using OpenRouter (Grok) via LiteLLM
+def get_model():
+    """Returns a configured LiteLlm model instance for OpenRouter."""
+    # Configure OpenRouter endpoint
+    os.environ["OPENAI_API_BASE"] = "https://openrouter.ai/api/v1"
+    os.environ["OPENAI_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
+    
+    # Use the requested Grok model
+    # LiteLLM uses 'openai/' prefix for OpenAI-compatible endpoints
+    model = LiteLlm(model="openai/x-ai/grok-4.1-fast:free")
+    
+    logger.info("✅ Model initialized: x-ai/grok-4.1-fast:free via OpenRouter")
+    return model
+
+
+# ===== GEMINI MODEL INITIALIZATION =====
+# Using Google Gemini for Search Agents
+from google.adk.models.google_llm import Gemini
+Model="gemini-2.0-flash-lite"
+def get_gemini_model():
+    """Returns a configured Gemini model instance."""
+    model = Gemini(model=Model)
+    logger.info(f"✅ Model initialized: {Model}")
+    return model
+
+
+# ===== SESSION SERVICE INITIALIZATION =====
+# Using DatabaseSessionService with SQLite + AsyncIO driver
+def get_session_service(db_url=None):
+    """
+    Returns a configured DatabaseSessionService instance.
+    
+    Args:
+        db_url: Database connection string. 
+                Defaults to DATABASE_URL env var, or local SQLite if not set.
+    """
+    # Prioritize argument, then env var, then local default
+    if not db_url:
+        # Use legacy_solver.db as it contains the existing sessions
+        db_url = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///legacy_solver.db")
+        
+    session_service = DatabaseSessionService(db_url=db_url)
+    logger.info(f"✅ Session service initialized: {db_url.split('://')[0]}://...") # Log safe URL
+    return session_service
+
+
+# ===== MEMORY SERVICE INITIALIZATION =====
+# Using InMemoryMemoryService for simplicity (DatabaseMemoryService not available in this ADK version)
+from google.adk.memory import InMemoryMemoryService
+
+def get_memory_service():
+    """
+    Returns a configured MemoryService instance.
+    Uses Pinecone if PINECONE_API_KEY is set, otherwise InMemory.
+    """
+    pinecone_key = os.getenv("PINECONE_API_KEY")
+    logger.info(f"🔍 Checking PINECONE_API_KEY: {'Found' if pinecone_key else 'Missing'}")
+    
+    if pinecone_key:
+        try:
+            from .memory import PineconeMemoryService
+            memory_service = PineconeMemoryService(api_key=pinecone_key)
+            logger.info("✅ Memory service initialized: Pinecone (Long-Term Vector Store)")
+            return memory_service
+        except Exception as e:
+            logger.error(f"❌ Failed to init Pinecone, falling back to InMemory: {e}")
+            
+    memory_service = InMemoryMemoryService()
+    logger.info("✅ Memory service initialized: InMemory (Ephemeral)")
+    return memory_service

src/memory.py

@@ -0,0 +1,123 @@
+import os
+import uuid
+from typing import List, Dict, Any
+from typing import List, Dict, Any
+# from google.adk.memory import MemoryService # Not available in this version
+from pinecone import Pinecone, ServerlessSpec
+from sentence_transformers import SentenceTransformer
+from .utils import logger
+
+class PineconeMemoryService: # Removed inheritance to avoid ImportError
+    """
+    Custom Memory Service using Pinecone for long-term vector storage.
+    Uses 'all-MiniLM-L6-v2' for local embedding generation.
+    """
+    def __init__(self, api_key: str, index_name: str = "adk-memory", dimension: int = 384):
+        self.api_key = api_key
+        self.index_name = index_name
+        self.dimension = dimension
+        
+        # Initialize Pinecone
+        self.pc = Pinecone(api_key=self.api_key)
+        
+        # Create index if not exists
+        if self.index_name not in self.pc.list_indexes().names():
+            logger.info(f"🌲 Creating Pinecone index: {self.index_name}")
+            self.pc.create_index(
+                name=self.index_name,
+                dimension=self.dimension,
+                metric="cosine",
+                spec=ServerlessSpec(cloud="aws", region="us-east-1") # Default free tier region
+            )
+            
+        self.index = self.pc.Index(self.index_name)
+        
+        # Initialize Embedding Model
+        logger.info("🧠 Loading embedding model: all-MiniLM-L6-v2... (This may take a while if downloading)")
+        print("DEBUG: Starting SentenceTransformer load...")
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        print("DEBUG: SentenceTransformer loaded.")
+        logger.info("✅ Pinecone Memory Service initialized")
+
+    async def add_session_to_memory(self, session: Any):
+        """
+        Embeds the session history and saves it to Pinecone.
+        """
+        try:
+            # Get session ID safely (ADK sessions usually use .id)
+            session_id = getattr(session, 'id', getattr(session, 'session_id', 'UNKNOWN'))
+            
+            logger.info(f"💾 Attempting to save session to Pinecone. Session ID: {session_id}")
+            # Debug session structure
+            # logger.info(f"Session dir: {dir(session)}")
+
+            # 1. Convert session to text
+            # Assuming session has a 'history' or we can iterate turns
+            # We'll construct a simplified text representation
+            text_content = ""
+            
+            # Check for 'turns' or 'events'
+            if hasattr(session, 'turns'):
+                turns = session.turns
+                logger.info(f"Found {len(turns)} turns.")
+                for turn in turns:
+                    text_content += f"{turn.role}: {turn.content}\n"
+            elif hasattr(session, 'events'):
+                events = session.events
+                logger.info(f"Found {len(events)} events.")
+                for event in events:
+                    # Event structure might vary
+                    author = getattr(event, 'author', 'unknown')
+                    content = getattr(event, 'content', getattr(event, 'text', ''))
+                    text_content += f"{author}: {content}\n"
+            else:
+                logger.warning("⚠️ Session has no 'turns' or 'events' attribute.")
+            
+            if not text_content.strip():
+                logger.warning("⚠️ Session content is empty. Skipping Pinecone save.")
+                return
+
+            # 2. Generate Embedding
+            vector = self.model.encode(text_content).tolist()
+            
+            # 3. Create Metadata
+            metadata = {
+                "session_id": session_id,
+                "text": text_content[:1000], # Store snippet (limit size)
+                "timestamp": str(session.created_at) if hasattr(session, 'created_at') else ""
+            }
+            
+            # 4. Upsert to Pinecone
+            # Use session_id as vector ID
+            self.index.upsert(vectors=[(session_id, vector, metadata)])
+            logger.info(f"💾 Saved session {session_id} to Pinecone")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to save to Pinecone: {e}")
+
+    async def search_memory(self, query: str, limit: int = 3) -> List[str]:
+        """
+        Searches Pinecone for relevant past sessions.
+        """
+        try:
+            # 1. Embed Query
+            query_vector = self.model.encode(query).tolist()
+            
+            # 2. Search Pinecone
+            results = self.index.query(
+                vector=query_vector,
+                top_k=limit,
+                include_metadata=True
+            )
+            
+            # 3. Format Results
+            memories = []
+            for match in results['matches']:
+                if match['score'] > 0.5: # Relevance threshold
+                    memories.append(match['metadata']['text'])
+            
+            return memories
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to search Pinecone: {e}")
+            return []

src/tools.py

@@ -0,0 +1,244 @@
+"""
+Tool definitions for the Legacy Dependency Solver.
+Includes Crawl4AI batch crawler for efficient multi-URL processing.
+"""
+from typing import List, Dict, Any
+import json
+import sys
+import asyncio
+import concurrent.futures
+from pydantic import BaseModel, Field
+
+from google.adk.tools import FunctionTool
+from .utils import logger
+from .config import get_memory_service # Import memory service factory
+
+# --- 1. Define Schema (Module level for pickling) ---
+class SearchResult(BaseModel):
+    relevant_facts: List[str] = Field(..., description="Specific facts/numbers found.")
+    summary: str = Field(..., description="Concise summary related to the query.")
+    confidence: str = Field(..., description="Confidence level (High/Medium/Low).")
+
+# --- 2. Worker Functions (Run in Subprocess) ---
+
+def _run_batch_crawl_worker(urls: List[str]) -> Dict[str, Any]:
+    """
+    Worker function to run batch crawl in a separate process.
+    """
+    # Enforce ProactorEventLoop on Windows for Playwright
+    if sys.platform == 'win32':
+        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+        
+    async def _async_logic():
+        from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode
+        
+        # Shared Config
+        browser_config = BrowserConfig(
+            headless=True,
+            ignore_https_errors=True,
+            extra_args=["--ignore-certificate-errors", "--ignore-ssl-errors"]
+        )
+        run_config = CrawlerRunConfig(
+            cache_mode=CacheMode.BYPASS,
+            word_count_threshold=10,
+        )
+        
+        results = []
+        # limit to top 3
+        target_urls = urls[:3]
+        
+        async with AsyncWebCrawler(config=browser_config) as crawler:
+            for url in target_urls:
+                try:
+                    crawl_result = await crawler.arun(url=url, config=run_config)
+                    if crawl_result.success:
+                        results.append(f"--- SOURCE: {url} ---\n{crawl_result.markdown[:15000]}\n")
+                    else:
+                        results.append(f"--- SOURCE: {url} ---\n[Error: Failed to crawl]\n")
+                except Exception as e:
+                    results.append(f"--- SOURCE: {url} ---\n[Exception: {str(e)}]\n")
+                    
+        return {
+            "combined_content": "\n".join(results),
+            "status": "completed"
+        }
+
+    return asyncio.run(_async_logic())
+
+
+def _run_adaptive_crawl_worker(start_url: str, user_query: str) -> Dict[str, Any]:
+    """
+    Worker function to run adaptive crawl in a separate process.
+    """
+    if sys.platform == 'win32':
+        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+        
+    async def _async_logic():
+        from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode, AdaptiveConfig, LLMConfig
+        from crawl4ai.extraction_strategy import LLMExtractionStrategy
+        
+        browser_config = BrowserConfig(
+            headless=True,
+            verbose=True,
+            ignore_https_errors=True,
+            extra_args=["--ignore-certificate-errors", "--ignore-ssl-errors"]
+        )
+        
+        async with AsyncWebCrawler(config=browser_config) as crawler:
+            # Phase 1: Discovery
+            adaptive_config = AdaptiveConfig(
+                max_pages=3,
+                confidence_threshold=0.7,
+                top_k_links=2,
+            )
+            
+            # Import inside function to avoid top-level import issues in subprocess if needed
+            from crawl4ai import AdaptiveCrawler
+            adaptive = AdaptiveCrawler(crawler, config=adaptive_config)
+            
+            try:
+                await adaptive.digest(start_url=start_url, query=user_query)
+            except Exception as e:
+                return {"error": f"Crawl failed during discovery: {str(e)}"}
+                
+            top_content = adaptive.get_relevant_content(top_k=1)
+            if not top_content:
+                return {"error": "No relevant content found via adaptive crawling."}
+                
+            best_url = top_content[0]['url']
+            
+            # Phase 2: Extraction
+            dynamic_instruction = f"""
+            Extract ONLY information matching this request: '{user_query}'.
+            If not found, state that in the summary. Do not hallucinate.
+            """
+            
+            extraction_config = CrawlerRunConfig(
+                cache_mode=CacheMode.BYPASS,
+                word_count_threshold=1,
+                page_timeout=60000,
+                extraction_strategy=LLMExtractionStrategy(
+                    llm_config=LLMConfig(provider="ollama/qwen2.5:7b", api_token="ollama"),
+                    schema=SearchResult.model_json_schema(),
+                    extraction_type="schema",
+                    instruction=dynamic_instruction,
+                ),
+            )
+            
+            try:
+                result = await crawler.arun(url=best_url, config=extraction_config)
+                if result.extracted_content:
+                    return json.loads(result.extracted_content)
+                return {"error": "Extraction returned empty content."}
+            except json.JSONDecodeError:
+                return {"raw_output": result.extracted_content}
+            except Exception as e:
+                return {"error": f"Extraction failed: {str(e)}"}
+
+    return asyncio.run(_async_logic())
+
+
+# --- 3. Main Tools (Async Wrappers) ---
+
+async def batch_crawl_tool(urls: List[str]) -> Dict[str, Any]:
+    """
+    Crawls a LIST of URLs in one go using a subprocess to ensure correct event loop.
+    """
+    logger.info(f"🚀 Batch Tool Triggered: Processing {len(urls)} URLs...")
+    
+    loop = asyncio.get_running_loop()
+    with concurrent.futures.ProcessPoolExecutor() as pool:
+        try:
+            result = await loop.run_in_executor(pool, _run_batch_crawl_worker, urls)
+            return result
+        except Exception as e:
+            logger.error(f"❌ Batch crawl subprocess failed: {e}")
+            return {"combined_content": f"Error: {str(e)}", "status": "failed"}
+
+async def adaptive_crawl_tool(start_url: str, user_query: str) -> Dict[str, Any]:
+    """
+    Performs adaptive crawl using a subprocess.
+    """
+    logger.info(f"🛠️ Tool Triggered: Adaptive Crawl on {start_url}")
+    
+    loop = asyncio.get_running_loop()
+    with concurrent.futures.ProcessPoolExecutor() as pool:
+        try:
+            result = await loop.run_in_executor(pool, _run_adaptive_crawl_worker, start_url, user_query)
+            return result
+        except Exception as e:
+            logger.error(f"❌ Adaptive crawl subprocess failed: {e}")
+            return {"error": f"Subprocess failed: {str(e)}"}
+
+
+# Convert to ADK Tools
+batch_tool = FunctionTool(batch_crawl_tool)
+adaptive_tool = FunctionTool(adaptive_crawl_tool)
+
+
+# ===== STATE MANAGEMENT TOOLS =====
+from google.adk.tools import ToolContext
+
+def save_context(tool_context: ToolContext, key: str, value: str) -> str:
+    tool_context.state[key] = value
+    logger.info(f"💾 State Saved: {key} = {value}")
+    return f"Saved {key} to state."
+
+def retrieve_context(tool_context: ToolContext, key: str) -> str:
+    value = tool_context.state.get(key, "Not found")
+    logger.info(f"📂 State Retrieved: {key} = {value}")
+    return str(value)
+
+save_context_tool = FunctionTool(save_context)
+retrieve_context_tool = FunctionTool(retrieve_context)
+
+def submit_queries(tool_context: ToolContext, queries: List[str]) -> str:
+    tool_context.state['search_queries'] = queries
+    logger.info(f"🚀 Queries Submitted: {queries}")
+    return "Queries submitted successfully."
+
+submit_queries_tool = FunctionTool(submit_queries)
+
+def validate_requirements(tool_context: ToolContext, requirements_content: str) -> str:
+    if not requirements_content:
+        return "Error: Empty requirements content."
+    lines = requirements_content.strip().split('\n')
+    errors = []
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        import re
+        if not re.match(r'^[a-zA-Z0-9_\-]+[=<>!~]+[0-9a-zA-Z\.]+', line):
+             if not re.match(r'^[a-zA-Z0-9_\-]+$', line):
+                 errors.append(f"Invalid syntax: {line}")
+    if errors:
+        return f"Validation Failed: {'; '.join(errors)}"
+    logger.info("✅ Requirements validation passed.")
+    return "SUCCESS"
+
+validate_tool = FunctionTool(validate_requirements)
+
+# ===== MEMORY RETRIEVAL TOOL =====
+async def retrieve_memory(query: str) -> str:
+    """
+    Searches long-term memory (Pinecone) for relevant past sessions.
+    Use this to recall details from previous conversations.
+    """
+    logger.info(f"🧠 Searching Memory for: {query}")
+    try:
+        # Initialize service on demand (or use singleton if configured)
+        memory_service = get_memory_service()
+        results = await memory_service.search_memory(query)
+        
+        if not results:
+            return "No relevant memories found."
+            
+        formatted_results = "\n---\n".join(results)
+        return f"Found relevant memories:\n{formatted_results}"
+        
+    except Exception as e:
+        logger.error(f"❌ Memory retrieval failed: {e}")
+        return f"Error retrieving memory: {str(e)}"
+
+retrieve_memory_tool = FunctionTool(retrieve_memory)

src/utils.py

@@ -0,0 +1,25 @@
+"""
+Utility functions for logging and helpers.
+"""
+import logging
+import sys
+
+
+def setup_logging(level=logging.INFO):
+    """
+    Setup standard logging configuration.
+    
+    Args:
+        level: Logging level (default: INFO)
+    """
+    logging.basicConfig(
+        level=level,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    return logging.getLogger(__name__)
+
+
+logger = setup_logging()

web_app.py

@@ -0,0 +1,91 @@
+"""
+Web Interface Entry Point for ADK Web UI.
+Run with: python web_app.py
+"""
+import os
+import nest_asyncio
+import uvicorn
+from typing import Optional, Any
+from google.adk.cli.adk_web_server import (
+    AdkWebServer, BaseAgentLoader, EvalSetsManager, EvalSetResultsManager,
+    BaseCredentialService
+)
+from google.adk.artifacts import FileArtifactService
+from src.config import get_session_service, get_memory_service
+from src.agents import create_root_agent
+from src.utils import logger
+
+# Apply nest_asyncio to handle event loop conflicts
+nest_asyncio.apply()
+
+class SingleAgentLoader(BaseAgentLoader):
+    """Custom loader that serves our single root agent."""
+    def __init__(self, agent):
+        self.agent = agent
+        self.agent_name = "package_conflict_resolver"
+
+    def list_agents(self) -> list[str]:
+        return [self.agent_name]
+
+    def load_agent(self, agent_name: str):
+        if agent_name == self.agent_name:
+            return self.agent
+        raise ValueError(f"Agent {agent_name} not found")
+
+class LocalCredentialService(BaseCredentialService):
+    """Simple credential service implementation."""
+    def __init__(self, base_dir: str):
+        self.base_dir = base_dir
+        os.makedirs(base_dir, exist_ok=True)
+
+    def load_credential(self, auth_config: Any, callback_context: Any) -> Optional[Any]:
+        # Dummy implementation: return None or load from file if needed
+        # For now, we don't persist credentials, so returning None is safe
+        return None
+
+    def save_credential(self, auth_config: Any, callback_context: Any) -> None:
+        # Dummy implementation: do nothing
+        pass
+
+if __name__ == "__main__":
+    logger.info("🌐 Initializing ADK Web Server...")
+
+    # 1. Initialize Services
+    session_service = get_session_service()
+    memory_service = get_memory_service()
+    
+    data_dir = os.path.abspath("data")
+    os.makedirs(data_dir, exist_ok=True)
+    
+    # Corrected: use root_dir instead of base_dir
+    artifact_service = FileArtifactService(root_dir=os.path.join(data_dir, "artifacts"))
+    
+    # Use custom LocalCredentialService with implemented abstract methods
+    credential_service = LocalCredentialService(base_dir=os.path.join(data_dir, "credentials"))
+    
+    eval_sets_manager = EvalSetsManager(base_dir=os.path.join(data_dir, "eval_sets"))
+    eval_set_results_manager = EvalSetResultsManager(base_dir=os.path.join(data_dir, "eval_results"))
+
+    # 2. Create Agent
+    root_agent = create_root_agent()
+    agent_loader = SingleAgentLoader(root_agent)
+
+    # 3. Initialize Web Server
+    server = AdkWebServer(
+        agent_loader=agent_loader,
+        session_service=session_service,
+        memory_service=memory_service,
+        artifact_service=artifact_service,
+        credential_service=credential_service,
+        eval_sets_manager=eval_sets_manager,
+        eval_set_results_manager=eval_set_results_manager,
+        agents_dir=os.path.abspath("src")
+    )
+
+    # 4. Get FastAPI App
+    app = server.get_fast_api_app()
+
+    logger.info("🚀 Starting Server...")
+    logger.info("👉 Open: http://127.0.0.1:8000/dev-ui/")
+    
+    uvicorn.run(app, host="127.0.0.1", port=8000)