Æon Framework

# Install from PyPI
pip install aeon-core

# Or install from source for development
git clone https://github.com/richardsonlima/aeon-core.git
cd aeon-core
pip install -e .

# On Mac
brew install ollama

# On Linux
curl https://ollama.ai/install.sh | sh

# Then start the service
ollama serve

# Download mistral (recommended)
ollama pull mistral

# Check available models
ollama list

from aeon import Agent

agent = Agent(
    name="MyAssistant",
    model_provider="ollama",
    model_name="mistral",
    base_url="http://localhost:11434"
)

agent.start()  # Listen on http://localhost:8000

export OPENAI_API_KEY="sk-..."

from aeon import Agent

agent = Agent(
    name="MyAssistant",
    model_provider="openai",
    model_name="gpt-4o",
    api_key="sk-..."  # or use $OPENAI_API_KEY env var
)

agent.start()

export OPENROUTER_API_KEY="sk-or-..."

from aeon import Agent

# Example 1: Use Claude
agent = Agent(
    name="MyAssistant",
    model_provider="openrouter",
    model_name="anthropic/claude-opus-4-6"
)

# Example 2: Use Gemini
agent = Agent(
    name="MyAssistant",
    model_provider="openrouter",
    model_name="google/gemini-2.0-flash"
)

# Example 3: Dynamic model selection
import os
model = os.getenv("AI_MODEL", "anthropic/claude-opus-4-6")
agent = Agent(name="MyAssistant", model_provider="openrouter", model_name=model)

agent.start()

# Set AWS credentials
export AWS_ACCESS_KEY_ID="AKIA..."
export AWS_SECRET_ACCESS_KEY="..."
export AWS_REGION="us-east-1"

# Verify Bedrock models are enabled
aws bedrock list-foundation-models --region us-east-1

from aeon import Agent

agent = Agent(
    name="MyAssistant",
    model_provider="bedrock",
    model_name="anthropic.claude-opus-4-6"
    # AWS credentials loaded automatically from environment
)

agent.start()

#!/usr/bin/env python3
"""Simple chat with local Ollama"""

from aeon import Agent
import asyncio

async def main():
    # Initialize agent with Ollama
    agent = Agent(
        name="LocalChat",
        model_provider="ollama",
        model_name="mistral",
        base_url="http://localhost:11434"
    )
    
    print("💬 Chat with your AI (type 'exit' to quit)")
    print("=" * 50)
    
    while True:
        user_input = input("\nYou: ").strip()
        
        if user_input.lower() == 'exit':
            print("Goodbye! 👋")
            break
        
        if not user_input:
            continue
        
        try:
            # Get response from agent
            response = await agent.ask(user_input)
            print(f"\n🤖 Assistant: {response}")
        except Exception as e:
            print(f"❌ Error: {e}")

if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
"""Simple chat with OpenAI GPT-4o"""

from aeon import Agent
import asyncio
import os

async def main():
    # Initialize agent with OpenAI
    agent = Agent(
        name="OpenAIChat",
        model_provider="openai",
        model_name="gpt-4o",
        api_key=os.getenv("OPENAI_API_KEY")
    )
    
    print("💬 Chat with GPT-4o (type 'exit' to quit)")
    print("=" * 50)
    
    while True:
        user_input = input("\nYou: ").strip()
        
        if user_input.lower() == 'exit':
            print("Goodbye! 👋")
            break
        
        if not user_input:
            continue
        
        try:
            response = await agent.ask(user_input)
            print(f"\n🤖 GPT-4o: {response}")
        except Exception as e:
            print(f"❌ Error: {e}")

if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
"""Chat with any provider - switch at runtime"""

from aeon import Agent
import asyncio
import os

async def main():
    # Create agents for different providers
    agents = {
        "ollama": Agent(
            name="OllamaChat",
            model_provider="ollama",
            model_name="mistral",
            base_url="http://localhost:11434"
        ),
        "openai": Agent(
            name="OpenAIChat",
            model_provider="openai",
            model_name="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY")
        ),
        "openrouter": Agent(
            name="OpenRouterChat",
            model_provider="openrouter",
            model_name="anthropic/claude-opus-4-6",
            api_key=os.getenv("OPENROUTER_API_KEY")
        )
    }
    
    current_provider = "ollama"
    print("🤖 Multi-Provider Chat")
    print("=" * 50)
    print("Commands:")
    print("  /switch  - Switch to different AI provider")
    print("  /exit - Quit")
    print()
    
    while True:
        user_input = input(f"\n[{current_provider}] You: ").strip()
        
        if user_input.startswith("/switch"):
            parts = user_input.split()
            if len(parts) > 1:
                provider = parts[1].lower()
                if provider in agents:
                    current_provider = provider
                    print(f"✅ Switched to {provider}")
                else:
                    print(f"❌ Unknown provider. Available: {', '.join(agents.keys())}")
            continue
        
        if user_input.lower() in ['/exit', 'exit']:
            break
        
        if not user_input:
            continue
        
        try:
            agent = agents[current_provider]
            response = await agent.ask(user_input)
            print(f"\n🤖 {current_provider.upper()}: {response}")
        except Exception as e:
            print(f"❌ Error with {current_provider}: {e}")

if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
"""AI Assistant on Telegram"""

from aeon import Agent
from aeon.integrations.telegram import TelegramProvider
import os

def main():
    # Initialize base agent
    agent = Agent(
        name="TelegramBot",
        model_provider="ollama",
        model_name="mistral"
    )
    
    # Add Telegram integration
    telegram_token = os.getenv("TELEGRAM_BOT_TOKEN")
    telegram = TelegramProvider(token=telegram_token)
    agent.integrations.register("telegram", telegram)
    
    print("✅ Telegram bot started!")
    print(f"Send messages to your Telegram bot")
    
    # Start listening
    agent.start()

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Bot that works on all platforms simultaneously"""

from aeon import Agent
from aeon.integrations.telegram import TelegramProvider
from aeon.integrations.discord import DiscordProvider
from aeon.integrations.slack import SlackProvider
import os

def main():
    # Initialize agent
    agent = Agent(
        name="UbiquitousBot",
        model_provider="openai",
        model_name="gpt-4o",
        api_key=os.getenv("OPENAI_API_KEY")
    )
    
    # Register all platforms
    platforms = {
        "telegram": TelegramProvider(token=os.getenv("TELEGRAM_BOT_TOKEN")),
        "discord": DiscordProvider(token=os.getenv("DISCORD_BOT_TOKEN")),
        "slack": SlackProvider(token=os.getenv("SLACK_BOT_TOKEN"))
    }
    
    for platform_name, provider in platforms.items():
        agent.integrations.register(platform_name, provider)
        print(f"✅ {platform_name} connected")
    
    print("\n🌐 Your bot is now available on:")
    print("  • Telegram")
    print("  • Discord")
    print("  • Slack")
    print("\nAll conversations use the same AI assistant!")
    
    agent.start()

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Personal AI Journal - Reflect on your day with AI"""

from aeon import Agent
from aeon.extensions.capability import Capability
from datetime import datetime
import json
import os

class JournalCapability(Capability):
    """Save and reflect on journal entries"""
    
    def __init__(self, journal_file="journal.json"):
        self.journal_file = journal_file
        self.entries = self._load_entries()
    
    def _load_entries(self):
        if os.path.exists(self.journal_file):
            with open(self.journal_file) as f:
                return json.load(f)
        return []
    
    def _save_entries(self):
        with open(self.journal_file, 'w') as f:
            json.dump(self.entries, f, indent=2)
    
    async def save_entry(self, text: str):
        """Save a new journal entry"""
        entry = {
            "date": datetime.now().isoformat(),
            "text": text
        }
        self.entries.append(entry)
        self._save_entries()
        return f"✅ Entry saved ({len(self.entries)} total)"
    
    async def list_entries(self):
        """List all entries with dates"""
        if not self.entries:
            return "No entries yet"
        result = "📖 Your Journal:\n"
        for i, entry in enumerate(self.entries[-5:], 1):
            date = entry["date"][:10]
            preview = entry["text"][:50]
            result += f"{i}. [{date}] {preview}...\n"
        return result
    
    async def reflect(self, entry_index: int):
        """Get AI reflection on an entry"""
        if entry_index < 0 or entry_index >= len(self.entries):
            return "❌ Invalid entry"
        entry = self.entries[entry_index]
        return f"🤔 Reflection on {entry['date']}: {entry['text']}"

async def main():
    # Create agent
    agent = Agent(
        name="JournalBot",
        model_provider="ollama",
        model_name="mistral"
    )
    
    # Add journal capability
    journal = JournalCapability()
    agent.extensions.register(journal)
    
    print("📖 Personal Journal AI")
    print("=" * 50)
    print("Commands:")
    print("  journal save   - Save an entry")
    print("  journal list         - Show recent entries")
    print("  journal reflect   - Get AI reflection")
    print("  exit                 - Quit")
    
    while True:
        user_input = input("\n> ").strip()
        
        if user_input.lower() == "exit":
            break
        
        if user_input.startswith("journal save"):
            text = user_input[12:].strip()
            result = await journal.save_entry(text)
            print(result)
        
        elif user_input == "journal list":
            result = await journal.list_entries()
            print(result)
        
        elif user_input.startswith("journal reflect"):
            try:
                idx = int(user_input.split()[-1])
                result = await journal.reflect(idx - 1)
                print(result)
            except:
                print("❌ Usage: journal reflect ")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

#!/usr/bin/env python3
"""AI with web search capability"""

from aeon import Agent
from aeon.synapse.mcp import MCPClient
import os

async def main():
    # Create agent
    agent = Agent(
        name="SearchBot",
        model_provider="openrouter",
        model_name="anthropic/claude-opus-4-6",
        api_key=os.getenv("OPENROUTER_API_KEY")
    )
    
    # Add web search via MCP
    mcp = MCPClient(servers=["brave-search"])
    agent.synapse.register("tools", mcp)
    
    # Now you can search the web!
    response = await agent.ask(
        "What are the latest AI developments in 2024?"
    )
    print(f"🤖 {response}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

#!/usr/bin/env python3
"""Extract and summarize YouTube videos"""

from aeon import Agent
from aeon.synapse.mcp import MCPClient
import os

class YouTubeExtractor:
    def __init__(self, agent):
        self.agent = agent
        self.mcp = MCPClient(servers=["youtube"])
        self.agent.synapse.register("youtube", self.mcp)
    
    async def get_transcript(self, video_url: str):
        """Get transcript from YouTube video"""
        prompt = f"Extract transcript from: {video_url}"
        return await self.agent.ask(prompt)
    
    async def summarize_video(self, video_url: str):
        """Get AI summary of video"""
        prompt = f"Summarize this video: {video_url}"
        return await self.agent.ask(prompt)

async def main():
    agent = Agent(
        name="YouTubeSummary",
        model_provider="openai",
        model_name="gpt-4o",
        api_key=os.getenv("OPENAI_API_KEY")
    )
    
    extractor = YouTubeExtractor(agent)
    
    # Example
    url = "https://www.youtube.com/watch?v=..."
    summary = await extractor.summarize_video(url)
    print(f"📹 Summary:\n{summary}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

#!/usr/bin/env python3
"""AI Agent with Safety Rules"""

from aeon import Agent
from aeon.executive.axiom import Axiom
import re

class SafeAssistant:
    def __init__(self):
        self.agent = Agent(
            name="SafeBot",
            model_provider="ollama",
            model_name="mistral"
        )
        self.setup_axioms()
    
    def setup_axioms(self):
        """Define safety rules"""
        
        # Axiom 1: Block harmful content
        @Axiom(name="no_harmful_content", on_violation="BLOCK")
        def block_harmful(text: str) -> bool:
            harmful_keywords = [
                "bomb", "violence", "hack", "illegal",
                "personal data", "credit card", "password"
            ]
            return not any(kw in text.lower() for kw in harmful_keywords)
        
        # Axiom 2: Rate limiting
        @Axiom(name="rate_limit", on_violation="LIMIT")
        def rate_limit(request_count: int) -> bool:
            return request_count < 100  # Max 100 requests/hour
        
        # Axiom 3: Response length
        @Axiom(name="response_length", on_violation="TRUNCATE")
        def limit_response_length(response: str) -> bool:
            return len(response) < 5000  # Max 5000 chars
        
        # Register axioms
        self.agent.executive.add_axiom(block_harmful)
        self.agent.executive.add_axiom(rate_limit)
        self.agent.executive.add_axiom(limit_response_length)
    
    async def process_request(self, text: str):
        """Process request with safety validation"""
        # Axioms are checked automatically
        response = await self.agent.ask(text)
        return response

async def main():
    assistant = SafeAssistant()
    
    # Safe request ✅
    response = await assistant.process_request("What is AI?")
    print(f"✅ Safe response: {response}")
    
    # Potentially harmful request ❌
    response = await assistant.process_request("How to make a bomb?")
    print(f"❌ Blocked by axiom: {response}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

#!/usr/bin/env python3
"""Production-ready agent"""

from aeon import Agent
import logging

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

def main():
    agent = Agent(
        name="ProductionBot",
        model_provider="openai",
        model_name="gpt-4o",
        # Production settings
        timeout=30,
        max_retries=3,
        enable_metrics=True,
        enable_observability=True
    )
    
    print("🚀 Starting production agent...")
    agent.start(host="0.0.0.0", port=8000)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Agent with detailed logging"""

from aeon import Agent
import logging

# Setup detailed logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('agent.log'),
        logging.StreamHandler()
    ]
)

agent = Agent(
    name="DebugBot",
    model_provider="ollama",
    model_name="mistral",
    debug=True  # Enable debug mode
)

print("💾 Logs saved to agent.log")
agent.start()