Agno AI

from agno.agent import Agent
from agno.models.openai.like import OpenAILike

# Configure Portkey as the model provider
portkey_model = OpenAILike(
    id="@opeani-provider-slug/gpt-4o",  # You can use any model available on Portkey
    api_key="YOUR_PORTKEY_API_KEY",
    base_url="https://api.portkey.ai/v1",
)

# Create an Agno agent with Portkey
agent = Agent(
    model=portkey_model,
    instructions="Be concise and informative.",
    markdown=True,
)

# Run the agent
agent.print_response("What is Portkey AI?", stream=True)

from agno.agent import Agent
from agno.models.openai.like import OpenAILike
from agno.tools.yfinance import YFinanceTools
from portkey_ai import createHeaders

# Configure Portkey with enhanced tracking
portkey_model = OpenAILike(
    id="@anthropic/claude-3-sonnet-20240320",
    api_key="YOUR_PORTKEY_API_KEY",
    base_url="https://api.portkey.ai/v1",
    default_headers=createHeaders(
        trace_id="agno_finance_agent",
        metadata={
            "agent_type": "financial_analyst",
            "environment": "production"
        }
    )
)

agent = Agent(
    name="Financial Analyst",
    model=portkey_model,
    tools=[
        YFinanceTools(
            stock_price=True,
            company_info=True,
            analyst_recommendations=True,
            company_news=True
        )
    ],
    instructions=[
        "Provide comprehensive financial analysis",
        "Use tables for numerical data",
        "Include relevant news and recommendations",
        "Be concise but thorough"
    ],
    markdown=True,
    debug_mode=True  # See detailed agent reasoning
)

# Run analysis
agent.print_response(
    "Analyze Tesla's current financial position and recent performance",
    stream=True
)

from agno.agent import Agent
from agno.models.openai.like import OpenAILike
from agno.knowledge.url import UrlKnowledge
from agno.vectordb.lancedb import LanceDb, SearchType
from agno.embedder.openai import OpenAIEmbedder
from agno.storage.sqlite import SqliteStorage
from portkey_ai import createHeaders

# Configure Portkey with caching
cache_config = {
    "cache": {
        "mode": "semantic",
        "max_age": 3600  # Cache for 1 hour
    }
}

portkey_model = OpenAILike(
    id="opeani-provider-slug/gpt-4o",
    api_key="YOUR_PORTKEY_API_KEY",
    base_url="https://api.portkey.ai/v1",
    default_headers=createHeaders(
        config=cache_config,
        metadata={"agent_type": "knowledge_assistant"}
    )
)

# Set up knowledge base
knowledge = UrlKnowledge(
    urls=["https://docs.agno.com/introduction.md"],
    vector_db=LanceDb(
        uri="tmp/lancedb",
        table_name="agno_docs",
        search_type=SearchType.hybrid,
        embedder=OpenAIEmbedder(id="text-embedding-3-small", dimensions=1536),
    ),
)

# Configure storage
storage = SqliteStorage(table_name="agent_sessions", db_file="tmp/agent.db")

agent = Agent(
    name="Agno Assistant",
    model=portkey_model,
    knowledge=knowledge,
    storage=storage,
    instructions=[
        "Always search the knowledge base before answering",
        "Provide accurate information from the documentation",
        "If information isn't found, clearly state that"
    ],
    add_history_to_messages=True,
    num_history_runs=5,
    markdown=True
)

if __name__ == "__main__":
    # Load knowledge base (only needed first time)
    agent.knowledge.load(recreate=False)

    # Ask questions - responses will be cached by Portkey
    agent.print_response("What are the key features of Agno?", stream=True)

from agno.agent import Agent
from agno.models.openai.like import OpenAILike
from agno.memory.v2.memory import Memory
from agno.memory.v2.db.sqlite import SqliteMemoryDb
from agno.tools.reasoning import ReasoningTools
from agno.tools.yfinance import YFinanceTools
from portkey_ai import createHeaders

# Configure Portkey with fallbacks and retries
reliability_config = {
    "strategy": {
        "mode": "fallback"
    },
    "targets": [
        {
            "override_params": {"model": "@opeani-provider-slug/gpt-4o"}
        },
        {
            "override_params": {"model": "@anthropic-provider-slug/@anthropic-provider-slug/claude-3-opus-20240229"}
        }
    ],
    "retry": {
        "attempts": 3,
        "delay": 2
    }
}

portkey_model = OpenAILike(
    id="@opeani-provider-slug/gpt-4o",
    api_key="YOUR_PORTKEY_API_KEY",
    base_url="https://api.portkey.ai/v1",
    default_headers=createHeaders(
        config=reliability_config,
        trace_id="advanced_trading_agent"
    )
)

# Set up memory
memory = Memory(
    model=portkey_model,
    db=SqliteMemoryDb(table_name="user_memories", db_file="tmp/agent.db"),
    delete_memories=True,
    clear_memories=True,
)

agent = Agent(
    name="Trading Assistant",
    model=portkey_model,
    tools=[
        ReasoningTools(add_instructions=True),
        YFinanceTools(
            stock_price=True,
            analyst_recommendations=True,
            company_info=True,
            company_news=True
        ),
    ],
    user_id="trader_1",
    instructions=[
        "Remember user preferences and trading patterns",
        "Use reasoning to analyze market conditions",
        "Provide data-driven recommendations",
        "Display results in clear tables"
    ],
    memory=memory,
    enable_agentic_memory=True,
    markdown=True,
)

if __name__ == "__main__":
    # First interaction - agent learns preferences
    agent.print_response(
        "I'm interested in tech stocks, particularly AI companies like NVIDIA and Microsoft",
        stream=True,
        show_full_reasoning=True,
    )

    # Second interaction - agent uses memory
    agent.print_response(
        "Based on my interests, what stocks should I watch today?",
        stream=True,
        show_full_reasoning=True,
    )