mangaba 0.1.0__tar.gz

mangaba-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include requirements.txt
+recursive-include examples *.py 

mangaba-0.1.0/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: mangaba
+Version: 0.1.0
+Summary: Framework Python para criacao de equipes de agentes AI autonomos
+Home-page: https://github.com/dheiver2/mangaba_ai
+Author: Dheiver Santos
+Author-email: Dheiver Santos <dheiver.santos@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dheiver2/mangaba_ai
+Project-URL: Bug Tracker, https://github.com/dheiver2/mangaba_ai/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Mangaba - Framework de Automacao com Agentes Inteligentes
+
+<img src="https://github.com/dheiver2/mangaba_ai/blob/main/img.png" width="300">
+
+Framework Python para criacao de equipes de agentes AI autonomos que colaboram para resolver tarefas complexas.
+
+## ✨ Funcionalidades Principais
+
+- **Arquitetura Multi-Agente**: Crie equipes de agentes especializados
+- **Memoria Contextual**: Historico individual e compartilhado entre agentes
+- **Integracao Gemini**: Utilize os modelos mais avancados da Google
+- **Ferramentas Externas**: Busca no Google e outras APIs
+- **Gerenciamento de Tarefas**: Dependencias e priorizacao automatica
+- **Processamento Assincrono**: Execucao paralela para maior eficiencia
+
+## 🚀 Comecando
+
+### Pre-requisitos
+- Python 3.9+
+- Conta no Google AI Studio (para API key do Gemini)
+
+### Instalacao
+
+**Metodo 1: Instalacao via pip (mais simples)**
+```bash
+pip install mangaba
+```
+
+**Metodo 2: Instalacao direta do repositorio com pre-instalacao**
+```bash
+git clone https://github.com/dheiver2/mangaba_ai.git
+cd mangaba_ai
+# Execute o script de pre-instalacao das dependencias (recomendado)
+python setup.py.pre
+# Depois instale o pacote
+pip install .
+```
+
+**Metodo 3: Instalacao com requisitos em lote**
+```bash
+git clone https://github.com/dheiver2/mangaba_ai.git
+cd mangaba_ai
+# Primeiro instale as dependencias
+pip install -r requirements.txt
+# Depois instale o pacote
+pip install .
+```
+
+### Verificacao da Instalacao
+Para verificar se o Mangaba foi instalado corretamente, execute:
+```python
+import mangaba
+print(mangaba.__version__)  # Deve exibir a versao atual
+```
+
+### Solucao de problemas
+
+1. Se encontrar erros sobre dependencias, instale-as manualmente:
+```bash
+pip install google-generativeai googlesearch-python requests aiohttp tenacity
+```
+
+2. Para ambiente Windows com problemas de codificacao:
+```bash
+set PYTHONIOENCODING=utf-8
+pip install mangaba
+```
+
+3. Em caso de falha na instalacao em modo editavel:
+```bash
+python setup.py develop
+```
+
+### Configuracao
+1. Obtenha sua API key do Gemini em https://ai.google.dev/
+2. Configure a API em seu codigo:
+
+```python
+import mangaba
+from mangaba.config import configure_api
+
+# Configure a API com sua chave
+configure_api("sua_chave_aqui")
+```
+
+## 📚 Exemplo de Uso
+
+```python
+import asyncio
+import mangaba
+
+# Configure a API (veja secao de configuracao)
+
+async def exemplo():
+    # Criacao dos agentes
+    memory = mangaba.ContextualMemory()
+    model = mangaba.GeminiModel()
+    search_tool = mangaba.GoogleSearchTool()
+
+    pesquisador = mangaba.Agent(
+        name="Pesquisador", 
+        role="Busca dados", 
+        model=model, 
+        tools=[search_tool], 
+        memory=memory
+    )
+
+    # Definicao de tarefas
+    tarefa = mangaba.Task(
+        description="Buscar inovacoes em IA", 
+        agent=pesquisador
+    )
+
+    # Execucao
+    equipe = mangaba.Crew(agents=[pesquisador], tasks=[tarefa])
+    await equipe.run()
+    
+    # Resultado
+    print(tarefa.result)
+
+if __name__ == "__main__":
+    asyncio.run(exemplo())
+```
+
+## 🏗 Estrutura do Projeto
+
+```
+mangaba/
+├── __init__.py        # Exporta as classes principais
+├── config/            # Modulo de configuracao
+│   ├── __init__.py
+│   └── api.py         # Funcoes para configuracao da API
+├── core/              # Modulo principal
+│   ├── __init__.py
+│   └── models.py      # Definicoes das classes principais
+└── cases/             # Casos de uso
+    ├── __init__.py
+    └── cases.py       # Exemplos prontos
+```
+
+## 🤝 Como Contribuir
+
+1. Faca um fork do projeto
+2. Crie sua branch (`git checkout -b feature/nova-funcionalidade`)
+3. Commit suas mudancas (`git commit -m 'Adiciona nova funcionalidade'`)
+4. Push para a branch (`git push origin feature/nova-funcionalidade`)
+5. Abra um Pull Request
+
+## 📄 Licenca
+
+Distribuido sob licenca MIT. Veja `LICENSE` para mais informacoes.
+
+## ✉️ Contato
+
+Dheiver Santos - [@dheiver](https://github.com/dheiver2) - dheiver.santos@gmail.com
+
+Project Link: [https://github.com/dheiver2/mangaba_ai](https://github.com/dheiver2/mangaba_ai)

mangaba-0.1.0/README.md

@@ -0,0 +1,157 @@
+# Mangaba - Framework de Automacao com Agentes Inteligentes
+
+<img src="https://github.com/dheiver2/mangaba_ai/blob/main/img.png" width="300">
+
+Framework Python para criacao de equipes de agentes AI autonomos que colaboram para resolver tarefas complexas.
+
+## ✨ Funcionalidades Principais
+
+- **Arquitetura Multi-Agente**: Crie equipes de agentes especializados
+- **Memoria Contextual**: Historico individual e compartilhado entre agentes
+- **Integracao Gemini**: Utilize os modelos mais avancados da Google
+- **Ferramentas Externas**: Busca no Google e outras APIs
+- **Gerenciamento de Tarefas**: Dependencias e priorizacao automatica
+- **Processamento Assincrono**: Execucao paralela para maior eficiencia
+
+## 🚀 Comecando
+
+### Pre-requisitos
+- Python 3.9+
+- Conta no Google AI Studio (para API key do Gemini)
+
+### Instalacao
+
+**Metodo 1: Instalacao via pip (mais simples)**
+```bash
+pip install mangaba
+```
+
+**Metodo 2: Instalacao direta do repositorio com pre-instalacao**
+```bash
+git clone https://github.com/dheiver2/mangaba_ai.git
+cd mangaba_ai
+# Execute o script de pre-instalacao das dependencias (recomendado)
+python setup.py.pre
+# Depois instale o pacote
+pip install .
+```
+
+**Metodo 3: Instalacao com requisitos em lote**
+```bash
+git clone https://github.com/dheiver2/mangaba_ai.git
+cd mangaba_ai
+# Primeiro instale as dependencias
+pip install -r requirements.txt
+# Depois instale o pacote
+pip install .
+```
+
+### Verificacao da Instalacao
+Para verificar se o Mangaba foi instalado corretamente, execute:
+```python
+import mangaba
+print(mangaba.__version__)  # Deve exibir a versao atual
+```
+
+### Solucao de problemas
+
+1. Se encontrar erros sobre dependencias, instale-as manualmente:
+```bash
+pip install google-generativeai googlesearch-python requests aiohttp tenacity
+```
+
+2. Para ambiente Windows com problemas de codificacao:
+```bash
+set PYTHONIOENCODING=utf-8
+pip install mangaba
+```
+
+3. Em caso de falha na instalacao em modo editavel:
+```bash
+python setup.py develop
+```
+
+### Configuracao
+1. Obtenha sua API key do Gemini em https://ai.google.dev/
+2. Configure a API em seu codigo:
+
+```python
+import mangaba
+from mangaba.config import configure_api
+
+# Configure a API com sua chave
+configure_api("sua_chave_aqui")
+```
+
+## 📚 Exemplo de Uso
+
+```python
+import asyncio
+import mangaba
+
+# Configure a API (veja secao de configuracao)
+
+async def exemplo():
+    # Criacao dos agentes
+    memory = mangaba.ContextualMemory()
+    model = mangaba.GeminiModel()
+    search_tool = mangaba.GoogleSearchTool()
+
+    pesquisador = mangaba.Agent(
+        name="Pesquisador", 
+        role="Busca dados", 
+        model=model, 
+        tools=[search_tool], 
+        memory=memory
+    )
+
+    # Definicao de tarefas
+    tarefa = mangaba.Task(
+        description="Buscar inovacoes em IA", 
+        agent=pesquisador
+    )
+
+    # Execucao
+    equipe = mangaba.Crew(agents=[pesquisador], tasks=[tarefa])
+    await equipe.run()
+    
+    # Resultado
+    print(tarefa.result)
+
+if __name__ == "__main__":
+    asyncio.run(exemplo())
+```
+
+## 🏗 Estrutura do Projeto
+
+```
+mangaba/
+├── __init__.py        # Exporta as classes principais
+├── config/            # Modulo de configuracao
+│   ├── __init__.py
+│   └── api.py         # Funcoes para configuracao da API
+├── core/              # Modulo principal
+│   ├── __init__.py
+│   └── models.py      # Definicoes das classes principais
+└── cases/             # Casos de uso
+    ├── __init__.py
+    └── cases.py       # Exemplos prontos
+```
+
+## 🤝 Como Contribuir
+
+1. Faca um fork do projeto
+2. Crie sua branch (`git checkout -b feature/nova-funcionalidade`)
+3. Commit suas mudancas (`git commit -m 'Adiciona nova funcionalidade'`)
+4. Push para a branch (`git push origin feature/nova-funcionalidade`)
+5. Abra um Pull Request
+
+## 📄 Licenca
+
+Distribuido sob licenca MIT. Veja `LICENSE` para mais informacoes.
+
+## ✉️ Contato
+
+Dheiver Santos - [@dheiver](https://github.com/dheiver2) - dheiver.santos@gmail.com
+
+Project Link: [https://github.com/dheiver2/mangaba_ai](https://github.com/dheiver2/mangaba_ai)

mangaba-0.1.0/examples/basic_usage.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Exemplo basico de uso do pacote Mangaba.
+
+Este script demonstra como configurar e usar o Mangaba para criar
+uma equipe simples de agentes.
+"""
+
+import asyncio
+import os
+
+# Importando o pacote principal
+import mangaba
+from mangaba.config import configure_api
+
+# Definir sua chave API do Gemini (obtenha em https://ai.google.dev/)
+API_KEY = os.environ.get("GEMINI_API_KEY", "")
+if not API_KEY:
+    API_KEY = input("Digite sua chave de API do Gemini: ")
+
+# Configurar a API
+configure_api(API_KEY)
+
+async def simple_example():
+    """Exemplo simples de uso com um unico agente"""
+    # Criacao dos componentes basicos
+    memory = mangaba.ContextualMemory()
+    model = mangaba.GeminiModel()
+    search_tool = mangaba.GoogleSearchTool()
+    
+    # Criacao do agente
+    pesquisador = mangaba.Agent(
+        name="Pesquisador", 
+        role="Encontra informacoes", 
+        model=model, 
+        tools=[search_tool], 
+        memory=memory
+    )
+    
+    # Definicao da tarefa
+    tarefa = mangaba.Task(
+        description="Quais sao as tendencias tecnologicas para 2025?", 
+        agent=pesquisador
+    )
+    
+    # Execucao
+    equipe = mangaba.Crew(agents=[pesquisador], tasks=[tarefa])
+    await equipe.run()
+    
+    # Resultado
+    print("\nResultado final:")
+    print(tarefa.result)
+
+if __name__ == "__main__":
+    asyncio.run(simple_example()) 

mangaba-0.1.0/mangaba/__init__.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""
+Mangaba - Framework de Automacao com Agentes Inteligentes
+
+Um framework Python para criacao de equipes de agentes AI autonomos 
+que colaboram para resolver tarefas complexas.
+"""
+
+__version__ = "0.1.0"
+
+# Verificacao e instalacao automatica de dependencias
+import importlib.util
+import subprocess
+import sys
+import warnings
+
+
+def _check_and_install_dependency(package_name, pip_name=None):
+    """Verifica se um pacote esta instalado e o instala se necessario."""
+    if pip_name is None:
+        pip_name = package_name
+    
+    if importlib.util.find_spec(package_name) is None:
+        warnings.warn(
+            f"Dependencia '{package_name}' nao encontrada. Instalando automaticamente...",
+            ImportWarning
+        )
+        try:
+            subprocess.check_call(
+                [sys.executable, "-m", "pip", "install", pip_name],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL
+            )
+            print(f"[+] {package_name} instalado com sucesso!")
+        except subprocess.CalledProcessError:
+            raise ImportError(
+                f"Nao foi possivel instalar '{pip_name}' automaticamente. "
+                f"Por favor, instale manualmente com 'pip install {pip_name}'"
+            )
+
+
+# Verificacao de dependencias principais
+_check_and_install_dependency("google", "google-generativeai>=0.8.3")
+_check_and_install_dependency("googlesearch", "googlesearch-python>=1.2.1")
+_check_and_install_dependency("requests", "requests>=2.32.3")
+_check_and_install_dependency("aiohttp", "aiohttp>=3.10.5")
+_check_and_install_dependency("tenacity", "tenacity>=8.5.0")
+
+# Importa as classes principais para facilitar o acesso direto
+from mangaba.core.models import (
+    ContextualMemory,
+    GeminiModel,
+    GoogleSearchTool,
+    Agent,
+    Task,
+    Crew
+) 

mangaba-0.1.0/mangaba/cases/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""
+Modulo de casos de uso do Mangaba.
+
+Contem implementacoes de exemplos prontos para uso.
+"""
+
+from mangaba.cases.cases import case_mercado, case_educacao, main 

mangaba-0.1.0/mangaba/cases/cases.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# mangaba/cases/cases.py
+# Casos de uso do Mangaba
+
+import asyncio
+from mangaba.core.models import ContextualMemory, GeminiModel, GoogleSearchTool, Agent, Task, Crew
+
+# Case de Uso 1: Analise de Tendencias de Mercado
+async def case_mercado():
+    print("\n=== Case 1: Analise de Tendencias de Mercado ===")
+    memory = ContextualMemory(max_context_size=5)
+    model = GeminiModel(temperature=0.8, top_k=50)
+    search_tool = GoogleSearchTool()
+
+    pesquisador = Agent(name="Pesquisador", role="Busca dados", model=model, tools=[search_tool], memory=memory)
+    analista = Agent(name="Analista", role="Analisa dados", model=model, memory=memory)
+    escritor = Agent(name="Escritor", role="Escreve relatorio", model=model, memory=memory)
+
+    tarefa_pesquisa = Task(description="Buscar dados sobre tendencias em tecnologias verdes em 2025", agent=pesquisador, priority=2)
+    tarefa_analise = Task(description="Analisar os dados encontrados", agent=analista, priority=1, dependencies=[tarefa_pesquisa])
+    tarefa_relatorio = Task(description="Gerar relatorio executivo", agent=escritor, priority=0, dependencies=[tarefa_analise])
+
+    equipe = Crew(agents=[pesquisador, analista, escritor], tasks=[tarefa_pesquisa, tarefa_analise, tarefa_relatorio])
+    await equipe.run()
+
+# Case de Uso 2: Planejamento Educacional
+async def case_educacao():
+    print("\n=== Case 2: Planejamento Educacional ===")
+    memory = ContextualMemory(max_context_size=5)
+    model = GeminiModel(temperature=0.8, top_k=50)
+    search_tool = GoogleSearchTool()
+
+    pesquisador = Agent(name="Pesquisador", role="Busca dados", model=model, tools=[search_tool], memory=memory)
+    analista = Agent(name="Analista", role="Analisa dados", model=model, memory=memory)
+    escritor = Agent(name="Escritor", role="Escreve relatorio", model=model, memory=memory)
+
+    tarefa_pesquisa = Task(description="Buscar dados sobre IA na educacao em 2025", agent=pesquisador, priority=2)
+    tarefa_analise = Task(description="Analisar os dados encontrados", agent=analista, priority=1, dependencies=[tarefa_pesquisa])
+    tarefa_relatorio = Task(description="Gerar relatorio executivo", agent=escritor, priority=0, dependencies=[tarefa_analise])
+
+    equipe = Crew(agents=[pesquisador, analista, escritor], tasks=[tarefa_pesquisa, tarefa_analise, tarefa_relatorio])
+    await equipe.run()
+
+# Funcao principal para execucao
+async def main():
+    await case_mercado()
+    await case_educacao()
+
+if __name__ == "__main__":
+    asyncio.run(main())  # Usa asyncio.run para execucao fora do Colab; no Colab, use await main() 

mangaba-0.1.0/mangaba/config/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""
+Modulo de configuracao do Mangaba.
+
+Contem utilitarios para configuracao do framework.
+"""
+
+from mangaba.config.api import configure_api 

mangaba-0.1.0/mangaba/config/api.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# mangaba/config/api.py
+# Configuracao da API do Gemini para uso fora do Google Colab
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    raise ImportError(
+        "O pacote 'google-generativeai' nao esta instalado. "
+        "Execute 'pip install google-generativeai' para instala-lo."
+    )
+
+def configure_api(api_key: str):
+    """
+    Configura a API do Gemini com a chave fornecida.
+    
+    Args:
+        api_key (str): Chave de API do Gemini
+        
+    Returns:
+        bool: True se a configuracao foi bem-sucedida
+        
+    Raises:
+        ValueError: Se a chave de API for invalida
+    """
+    if not api_key:
+        raise ValueError(
+            "A chave da API nao pode estar vazia. "
+            "Obtenha uma chave em: https://ai.google.dev/"
+        )
+        
+    try:
+        genai.configure(api_key=api_key)
+        # Teste simples para verificar a API
+        test_model = genai.GenerativeModel("gemini-1.5-flash")
+        test_response = test_model.generate_content("Teste de API")
+        print("API do Gemini configurada com sucesso!")
+        return True
+    except Exception as e:
+        raise ValueError(f"Falha ao configurar a API do Gemini: {str(e)}") 

mangaba-0.1.0/mangaba/core/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""
+Modulo core do Mangaba.
+
+Contem as implementacoes das classes principais do framework.
+"""
+
+from mangaba.core.models import (
+    ContextualMemory,
+    GeminiModel,
+    GoogleSearchTool,
+    Agent,
+    Task,
+    Crew
+) 

mangaba-0.1.0/mangaba/core/models.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# mangaba/core/models.py
+# Definicoes das classes principais do Mangaba
+
+import asyncio
+from typing import List, Optional, Dict
+from dataclasses import dataclass
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    raise ImportError(
+        "O pacote 'google-generativeai' nao esta instalado. "
+        "Execute 'pip install google-generativeai' para instala-lo."
+    )
+
+try:
+    from googlesearch import search
+except ImportError:
+    raise ImportError(
+        "O pacote 'googlesearch-python' nao esta instalado. "
+        "Execute 'pip install googlesearch-python' para instala-lo."
+    )
+
+# ContextualMemory (com memoria global)
+class ContextualMemory:
+    def __init__(self, max_context_size: int = 10):
+        self.individual_data: Dict[str, List[str]] = {}
+        self.global_data: List[str] = []
+        self.max_context_size = max_context_size
+
+    def store_individual(self, agent_name: str, content: str):
+        agent_history = self.individual_data.setdefault(agent_name, [])
+        agent_history.append(content)
+        if len(agent_history) > self.max_context_size:
+            agent_history.pop(0)
+
+    def store_global(self, content: str):
+        self.global_data.append(content)
+        if len(self.global_data) > self.max_context_size:
+            self.global_data.pop(0)
+
+    def retrieve_individual(self, agent_name: str) -> List[str]:
+        return self.individual_data.get(agent_name, [])
+
+    def retrieve_global(self) -> List[str]:
+        return self.global_data
+
+# GeminiModel (com tratamento de erro)
+class GeminiModel:
+    def __init__(self, model_name: str = "gemini-1.5-flash", temperature: float = 0.7, top_k: int = 40):
+        self.model = genai.GenerativeModel(model_name)
+        self.temperature = temperature
+        self.top_k = top_k
+
+    async def generate(self, prompt: str) -> str:
+        try:
+            await asyncio.sleep(0.5)  # Simula latencia
+            response = self.model.generate_content(
+                prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=self.temperature,
+                    top_k=self.top_k
+                )
+            )
+            return response.text
+        except Exception as e:
+            return f"Erro na geracao: {str(e)}"
+
+# GoogleSearchTool (busca real)
+class GoogleSearchTool:
+    async def run(self, query: str) -> str:
+        await asyncio.sleep(0.3)  # Simula latencia de rede
+        try:
+            results = list(search(query, num_results=3))
+            return f"Resultados da busca: {', '.join(results)}"
+        except Exception as e:
+            return f"Erro na busca: {str(e)}"
+
+# Agent
+class Agent:
+    def __init__(self, name: str, role: str, model, tools: Optional[List] = None, memory=None):
+        self.name = name
+        self.role = role
+        self.model = model
+        self.tools = tools or []
+        self.memory = memory
+
+    async def execute(self, input_text: str, dependencies: List[str] = None) -> str:
+        print(f"[{self.name}] Executando: {input_text}")
+
+        individual_context = self.memory.retrieve_individual(self.name) if self.memory else []
+        global_context = self.memory.retrieve_global() if self.memory else []
+        deps_text = f"Dependencias: {dependencies}" if dependencies else ""
+        enriched_input = (
+            f"Contexto individual: {individual_context[-3:]}\n"
+            f"Contexto global: {global_context[-3:]}\n"
+            f"{deps_text}\nTarefa: {input_text}"
+        )
+
+        tool_outputs = []
+        for tool in self.tools:
+            tool_result = await tool.run(input_text)
+            tool_outputs.append(f"[{tool.__class__.__name__}] {tool_result}")
+
+        final_input = f"{enriched_input}\nResultados das ferramentas: {tool_outputs}" if tool_outputs else enriched_input
+
+        response = await self.model.generate(final_input)
+
+        if len(response) < 50:
+            response = await self.model.generate(f"{final_input}\nPor favor, forneca mais detalhes.")
+
+        if self.memory:
+            self.memory.store_individual(self.name, f"Entrada: {input_text}\nResposta: {response}")
+            self.memory.store_global(f"[{self.name}] {response}")
+
+        return response
+
+# Task
+@dataclass
+class Task:
+    description: str
+    agent: "Agent"
+    priority: int = 0
+    dependencies: Optional[List["Task"]] = None
+    result: Optional[str] = None
+    executed: bool = False  # Controle para evitar reexecucao
+
+    def get_dependencies_results(self) -> List[str]:
+        if not self.dependencies:
+            return []
+        return [task.result for task in self.dependencies if task.result]
+
+# Crew (com controle de execucao)
+class Crew:
+    def __init__(self, agents: List[Agent], tasks: List[Task]):
+        self.agents = {agent.name: agent for agent in agents}
+        self.tasks = sorted(tasks, key=lambda t: t.priority, reverse=True)
+
+    async def run_task(self, task: Task):
+        if task.executed:  # Evita executar a mesma tarefa mais de uma vez
+            return
+
+        if task.dependencies:
+            await asyncio.gather(*(self.run_task(dep) for dep in task.dependencies if not dep.executed))
+
+        agent = self.agents[task.agent.name]
+        dependencies_results = task.get_dependencies_results()
+        result = await agent.execute(task.description, dependencies_results)
+        task.result = result
+        task.executed = True  # Marca como executada
+        print(f"[{agent.name}] Resultado: {result}")
+
+    async def run(self):
+        await asyncio.gather(*(self.run_task(task) for task in self.tasks)) 

mangaba-0.1.0/mangaba.egg-info/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: mangaba
+Version: 0.1.0
+Summary: Framework Python para criacao de equipes de agentes AI autonomos
+Home-page: https://github.com/dheiver2/mangaba_ai
+Author: Dheiver Santos
+Author-email: Dheiver Santos <dheiver.santos@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dheiver2/mangaba_ai
+Project-URL: Bug Tracker, https://github.com/dheiver2/mangaba_ai/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Mangaba - Framework de Automacao com Agentes Inteligentes
+
+<img src="https://github.com/dheiver2/mangaba_ai/blob/main/img.png" width="300">
+
+Framework Python para criacao de equipes de agentes AI autonomos que colaboram para resolver tarefas complexas.
+
+## ✨ Funcionalidades Principais
+
+- **Arquitetura Multi-Agente**: Crie equipes de agentes especializados
+- **Memoria Contextual**: Historico individual e compartilhado entre agentes
+- **Integracao Gemini**: Utilize os modelos mais avancados da Google
+- **Ferramentas Externas**: Busca no Google e outras APIs
+- **Gerenciamento de Tarefas**: Dependencias e priorizacao automatica
+- **Processamento Assincrono**: Execucao paralela para maior eficiencia
+
+## 🚀 Comecando
+
+### Pre-requisitos
+- Python 3.9+
+- Conta no Google AI Studio (para API key do Gemini)
+
+### Instalacao
+
+**Metodo 1: Instalacao via pip (mais simples)**
+```bash
+pip install mangaba
+```
+
+**Metodo 2: Instalacao direta do repositorio com pre-instalacao**
+```bash
+git clone https://github.com/dheiver2/mangaba_ai.git
+cd mangaba_ai
+# Execute o script de pre-instalacao das dependencias (recomendado)
+python setup.py.pre
+# Depois instale o pacote
+pip install .
+```
+
+**Metodo 3: Instalacao com requisitos em lote**
+```bash
+git clone https://github.com/dheiver2/mangaba_ai.git
+cd mangaba_ai
+# Primeiro instale as dependencias
+pip install -r requirements.txt
+# Depois instale o pacote
+pip install .
+```
+
+### Verificacao da Instalacao
+Para verificar se o Mangaba foi instalado corretamente, execute:
+```python
+import mangaba
+print(mangaba.__version__)  # Deve exibir a versao atual
+```
+
+### Solucao de problemas
+
+1. Se encontrar erros sobre dependencias, instale-as manualmente:
+```bash
+pip install google-generativeai googlesearch-python requests aiohttp tenacity
+```
+
+2. Para ambiente Windows com problemas de codificacao:
+```bash
+set PYTHONIOENCODING=utf-8
+pip install mangaba
+```
+
+3. Em caso de falha na instalacao em modo editavel:
+```bash
+python setup.py develop
+```
+
+### Configuracao
+1. Obtenha sua API key do Gemini em https://ai.google.dev/
+2. Configure a API em seu codigo:
+
+```python
+import mangaba
+from mangaba.config import configure_api
+
+# Configure a API com sua chave
+configure_api("sua_chave_aqui")
+```
+
+## 📚 Exemplo de Uso
+
+```python
+import asyncio
+import mangaba
+
+# Configure a API (veja secao de configuracao)
+
+async def exemplo():
+    # Criacao dos agentes
+    memory = mangaba.ContextualMemory()
+    model = mangaba.GeminiModel()
+    search_tool = mangaba.GoogleSearchTool()
+
+    pesquisador = mangaba.Agent(
+        name="Pesquisador", 
+        role="Busca dados", 
+        model=model, 
+        tools=[search_tool], 
+        memory=memory
+    )
+
+    # Definicao de tarefas
+    tarefa = mangaba.Task(
+        description="Buscar inovacoes em IA", 
+        agent=pesquisador
+    )
+
+    # Execucao
+    equipe = mangaba.Crew(agents=[pesquisador], tasks=[tarefa])
+    await equipe.run()
+    
+    # Resultado
+    print(tarefa.result)
+
+if __name__ == "__main__":
+    asyncio.run(exemplo())
+```
+
+## 🏗 Estrutura do Projeto
+
+```
+mangaba/
+├── __init__.py        # Exporta as classes principais
+├── config/            # Modulo de configuracao
+│   ├── __init__.py
+│   └── api.py         # Funcoes para configuracao da API
+├── core/              # Modulo principal
+│   ├── __init__.py
+│   └── models.py      # Definicoes das classes principais
+└── cases/             # Casos de uso
+    ├── __init__.py
+    └── cases.py       # Exemplos prontos
+```
+
+## 🤝 Como Contribuir
+
+1. Faca um fork do projeto
+2. Crie sua branch (`git checkout -b feature/nova-funcionalidade`)
+3. Commit suas mudancas (`git commit -m 'Adiciona nova funcionalidade'`)
+4. Push para a branch (`git push origin feature/nova-funcionalidade`)
+5. Abra um Pull Request
+
+## 📄 Licenca
+
+Distribuido sob licenca MIT. Veja `LICENSE` para mais informacoes.
+
+## ✉️ Contato
+
+Dheiver Santos - [@dheiver](https://github.com/dheiver2) - dheiver.santos@gmail.com
+
+Project Link: [https://github.com/dheiver2/mangaba_ai](https://github.com/dheiver2/mangaba_ai)

mangaba-0.1.0/mangaba.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+examples/basic_usage.py
+mangaba/__init__.py
+mangaba.egg-info/PKG-INFO
+mangaba.egg-info/SOURCES.txt
+mangaba.egg-info/dependency_links.txt
+mangaba.egg-info/top_level.txt
+mangaba/cases/__init__.py
+mangaba/cases/cases.py
+mangaba/config/__init__.py
+mangaba/config/api.py
+mangaba/core/__init__.py
+mangaba/core/models.py

mangaba-0.1.0/mangaba.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mangaba-0.1.0/mangaba.egg-info/top_level.txt

@@ -0,0 +1 @@
+mangaba

mangaba-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mangaba"
+dynamic = ["version"]
+description = "Framework Python para criacao de equipes de agentes AI autonomos"
+readme = "README.md"
+authors = [{name = "Dheiver Santos", email = "dheiver.santos@gmail.com"}]
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+
+[project.urls]
+"Homepage" = "https://github.com/dheiver2/mangaba_ai"
+"Bug Tracker" = "https://github.com/dheiver2/mangaba_ai/issues" 

mangaba-0.1.0/requirements.txt

@@ -0,0 +1,7 @@
+google-generativeai>=0.8.3
+googlesearch-python>=1.2.1
+requests>=2.32.3
+aiohttp>=3.10.5
+tenacity>=8.5.0
+wheel>=0.38.0
+setuptools>=61.0.0

mangaba-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mangaba-0.1.0/setup.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup, find_packages
+import subprocess
+import sys
+
+# Garantir que as dependencias basicas de build estejam instaladas
+try:
+    import pip
+    print("[-] pip esta instalado")
+except ImportError:
+    print("[!] pip nao esta instalado corretamente")
+
+# Instalando dependencias antes da build
+DEPENDENCIES = [
+    "google-generativeai>=0.8.3",
+    "googlesearch-python>=1.2.1",
+    "requests>=2.32.3",
+    "aiohttp>=3.10.5",
+    "tenacity>=8.5.0",
+]
+
+print("[+] Instalando dependencias necessarias para a build...")
+for dep in DEPENDENCIES:
+    try:
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", dep],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        print(f"  [+] {dep}")
+    except subprocess.CalledProcessError:
+        print(f"  [!] Falha ao instalar {dep}")
+
+# Carrega o README para a descricao longa
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="mangaba",
+    version="0.1.0",
+    description="Framework Python para criacao de equipes de agentes AI autonomos",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Dheiver Santos",
+    author_email="dheiver.santos@gmail.com",
+    url="https://github.com/dheiver2/mangaba_ai",
+    packages=find_packages(),
+    install_requires=DEPENDENCIES,
+    setup_requires=["wheel"],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    python_requires=">=3.9",
+    keywords="ai, agents, llm, gemini, autonomous",
+)