| <<<<<<< HEAD | |
| --- | |
| title: SPARKNET | |
| sdk: streamlit | |
| app_file: demo/app.py | |
| python_version: "3.10" | |
| --- | |
| Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference | |
| ======= | |
| # SPARKNET: Agentic AI Workflow System | |
| Multi-agent orchestration system leveraging local LLM models via Ollama with multi-GPU support. | |
| ## Overview | |
| SPARKNET is an autonomous AI agent framework that enables: | |
| - **Multi-Agent Orchestration**: Specialized agents for planning, execution, and validation | |
| - **Local LLM Integration**: Uses Ollama for privacy-preserving AI inference | |
| - **Multi-GPU Support**: Efficiently utilizes 4x NVIDIA RTX 2080 Ti GPUs | |
| - **Tool-Augmented Agents**: Agents can use tools for file I/O, code execution, and system monitoring | |
| - **Memory Management**: Vector-based episodic and semantic memory | |
| - **Learning & Adaptation**: Feedback loops for continuous improvement | |
| ## System Requirements | |
| ### Hardware | |
| - NVIDIA GPUs with CUDA support (tested on 4x RTX 2080 Ti, 11GB VRAM each) | |
| - Minimum 16GB RAM | |
| - 50GB+ free disk space | |
| ### Software | |
| - Python 3.10+ | |
| - CUDA 12.0+ | |
| - Ollama installed and running | |
| ## Installation | |
| ### 1. Install Ollama | |
| ```bash | |
| # Install Ollama (if not already installed) | |
| curl -fsSL https://ollama.com/install.sh | sh | |
| # Start Ollama server | |
| ollama serve | |
| ``` | |
| ### 2. Install SPARKNET | |
| ```bash | |
| cd /home/mhamdan/SPARKNET | |
| # Install dependencies | |
| pip install -r requirements.txt | |
| # Install in development mode | |
| pip install -e . | |
| ``` | |
| ### 3. Download Recommended Models | |
| ```bash | |
| # Lightweight models | |
| ollama pull llama3.2:latest | |
| ollama pull phi3:latest | |
| # General purpose models | |
| ollama pull llama3.1:8b | |
| ollama pull mistral:latest | |
| # Large reasoning model | |
| ollama pull qwen2.5:14b | |
| # Embedding models | |
| ollama pull nomic-embed-text:latest | |
| ollama pull mxbai-embed-large:latest | |
| ``` | |
| ## Quick Start | |
| ### Basic Usage | |
| ```python | |
| from src.llm.ollama_client import OllamaClient | |
| from src.agents.executor_agent import ExecutorAgent | |
| from src.agents.base_agent import Task | |
| from src.tools import register_default_tools | |
| import asyncio | |
| # Initialize | |
| ollama_client = OllamaClient() | |
| tool_registry = register_default_tools() | |
| # Create agent | |
| agent = ExecutorAgent(llm_client=ollama_client) | |
| agent.set_tool_registry(tool_registry) | |
| # Create and execute task | |
| task = Task( | |
| id="task_1", | |
| description="List all Python files in the current directory", | |
| ) | |
| async def run(): | |
| result = await agent.process_task(task) | |
| print(f"Status: {result.status}") | |
| print(f"Result: {result.result}") | |
| asyncio.run(run()) | |
| ``` | |
| ### Running Examples | |
| ```bash | |
| # Simple agent with tool usage | |
| python examples/simple_task.py | |
| # Multi-agent collaboration | |
| python examples/multi_agent_collab.py | |
| # GPU monitoring | |
| python examples/gpu_monitor.py | |
| # Patent Wake-Up workflow (VISTA Scenario 1) | |
| python test_patent_wakeup.py | |
| ``` | |
| ## Patent Wake-Up Workflow (Phase 2C) | |
| SPARKNET now includes a complete **Patent Wake-Up workflow** for VISTA Scenario 1, which transforms dormant patents into commercialization opportunities. | |
| ### Quick Start | |
| ```bash | |
| # 1. Ensure required models are available | |
| ollama pull llama3.1:8b | |
| ollama pull mistral:latest | |
| ollama pull qwen2.5:14b | |
| # 2. Run the Patent Wake-Up workflow | |
| python test_patent_wakeup.py | |
| ``` | |
| ### Workflow Steps | |
| The Patent Wake-Up pipeline executes four specialized agents sequentially: | |
| 1. **DocumentAnalysisAgent** - Analyzes patent structure and assesses Technology Readiness Level (TRL) | |
| 2. **MarketAnalysisAgent** - Identifies market opportunities with size/growth data | |
| 3. **MatchmakingAgent** - Matches with potential partners using semantic search | |
| 4. **OutreachAgent** - Generates professional valorization briefs (PDF format) | |
| ### Example Output | |
| ``` | |
| Patent: AI-Powered Drug Discovery Platform | |
| TRL Level: 7/9 | |
| Market Opportunities: 4 identified ($150B+ addressable market) | |
| Stakeholder Matches: 10 partners (investors, companies, universities) | |
| Output: outputs/valorization_brief_[patent_id]_[date].pdf | |
| ``` | |
| ### Specialized Agents | |
| | Agent | Purpose | Model | Output | | |
| |-------|---------|-------|--------| | |
| | DocumentAnalysisAgent | Patent extraction & TRL assessment | llama3.1:8b | PatentAnalysis object | | |
| | MarketAnalysisAgent | Market opportunity identification | mistral:latest | MarketAnalysis object | | |
| | MatchmakingAgent | Stakeholder matching with scoring | qwen2.5:14b | List of StakeholderMatch | | |
| | OutreachAgent | Valorization brief generation | llama3.1:8b | ValorizationBrief + PDF | | |
| See `PHASE_2C_COMPLETE_SUMMARY.md` for full implementation details. | |
| ## Architecture | |
| ### Core Components | |
| 1. **Agents** (`src/agents/`) | |
| - `BaseAgent`: Core agent interface | |
| - `ExecutorAgent`: Task execution with tools | |
| - `PlannerAgent`: Task decomposition (coming soon) | |
| - `CriticAgent`: Output validation (coming soon) | |
| 2. **LLM Integration** (`src/llm/`) | |
| - `OllamaClient`: Interface to local Ollama models | |
| - Model routing based on task complexity | |
| 3. **Tools** (`src/tools/`) | |
| - File operations: read, write, search | |
| - Code execution: Python, bash | |
| - GPU monitoring and selection | |
| 4. **Utilities** (`src/utils/`) | |
| - GPU manager for resource allocation | |
| - Logging and configuration | |
| - Memory management | |
| ### Configuration | |
| Configuration files in `configs/`: | |
| - `system.yaml`: System-wide settings | |
| - `models.yaml`: Model routing rules | |
| - `agents.yaml`: Agent configurations | |
| ## Available Models | |
| | Model | Size | Use Case | | |
| |-------|------|----------| | |
| | llama3.2:latest | 2.0 GB | Classification, routing, simple QA | | |
| | phi3:latest | 2.2 GB | Quick reasoning, structured output | | |
| | mistral:latest | 4.4 GB | General tasks, creative writing | | |
| | llama3.1:8b | 4.9 GB | General tasks, code generation | | |
| | qwen2.5:14b | 9.0 GB | Complex reasoning, multi-step tasks | | |
| | nomic-embed-text | 274 MB | Text embeddings, semantic search | | |
| | mxbai-embed-large | 669 MB | High-quality embeddings, RAG | | |
| ## GPU Management | |
| SPARKNET automatically manages GPU resources: | |
| ```python | |
| from src.utils.gpu_manager import get_gpu_manager | |
| gpu_manager = get_gpu_manager() | |
| # Monitor all GPUs | |
| print(gpu_manager.monitor()) | |
| # Select best GPU with 8GB+ free | |
| with gpu_manager.gpu_context(min_memory_gb=8.0) as gpu_id: | |
| # Your model code here | |
| print(f"Using GPU {gpu_id}") | |
| ``` | |
| ## Development | |
| ### Project Structure | |
| ``` | |
| SPARKNET/ | |
| ├── src/ | |
| │ ├── agents/ # Agent implementations | |
| │ ├── llm/ # LLM client and routing | |
| │ ├── workflow/ # Task orchestration (coming soon) | |
| │ ├── memory/ # Memory systems (coming soon) | |
| │ ├── tools/ # Agent tools | |
| │ └── utils/ # Utilities | |
| ├── configs/ # Configuration files | |
| ├── examples/ # Example scripts | |
| ├── tests/ # Unit tests | |
| └── Dataset/ # Data directory | |
| ``` | |
| ### Running Tests | |
| ```bash | |
| pytest tests/ | |
| ``` | |
| ### Code Formatting | |
| ```bash | |
| black src/ | |
| flake8 src/ | |
| ``` | |
| ## Roadmap | |
| ### Phase 1: Foundation ✅ | |
| - [x] Project structure | |
| - [x] GPU manager | |
| - [x] Ollama client | |
| - [x] Base agent | |
| - [x] Basic tools | |
| - [x] Configuration system | |
| ### Phase 2: Multi-Agent System (In Progress) | |
| - [x] ExecutorAgent | |
| - [ ] PlannerAgent | |
| - [ ] CriticAgent | |
| - [ ] MemoryAgent | |
| - [ ] CoordinatorAgent | |
| - [ ] Agent communication protocol | |
| ### Phase 3: Advanced Features | |
| - [ ] Vector-based memory (ChromaDB) | |
| - [ ] Learning and feedback mechanisms | |
| - [ ] Model router | |
| - [ ] Workflow engine | |
| - [ ] Monitoring dashboard | |
| ### Phase 4: Optimization | |
| - [ ] Multi-GPU parallelization | |
| - [ ] Performance optimization | |
| - [ ] Comprehensive testing | |
| - [ ] Documentation | |
| ## Contributing | |
| Contributions are welcome! Please: | |
| 1. Fork the repository | |
| 2. Create a feature branch | |
| 3. Make your changes | |
| 4. Run tests | |
| 5. Submit a pull request | |
| ## License | |
| MIT License - see LICENSE file for details | |
| ## Acknowledgments | |
| - Ollama for local LLM inference | |
| - NVIDIA for CUDA and GPU support | |
| - The open-source AI community | |
| ## Support | |
| For issues and questions: | |
| - GitHub Issues: [Your repo URL] | |
| - Documentation: [Docs URL] | |
| --- | |
| Built with ❤️ for autonomous AI systems | |
| >>>>>>> e692211 (Initial commit: SPARKNET framework) | |