pip install aegis-research

from aegis_research import AegisResearch

client = AegisResearch(api_key="your_api_key")

# Run a research query
result = client.research("What are the key differences between REST and GraphQL APIs?")

print(result.summary)
print(f"Sources: {len(result.sources)}")

from aegis_research import ResearchDepth

# Quick lookup
quick = client.research("What is rate limiting?", depth=ResearchDepth.SHALLOW)

# In-depth analysis
detailed = client.research(
    "Compare authentication strategies for microservices",
    depth=ResearchDepth.DEEP
)

result = client.research("Best practices for Python logging")

# Summary paragraph
print(result.summary)

# Key findings as bullet points
for finding in result.key_findings:
    print(f"- {finding}")

# Detailed analysis
print(result.detailed_analysis)

# Source citations
for source in result.sources:
    print(f"[{source.title}]({source.url}) - relevance: {source.relevance_score}")

# Check your balance
credits = client.credits()
print(f"Available: {credits.available}")
print(f"Used this month: {credits.used}")
print(f"Plan: {credits.plan}")

# View pricing tiers
pricing = client.pricing()
for tier in pricing:
    print(f"{tier['name']}: {tier['credits_per_month']} credits - ${tier['price']}/mo")

import asyncio
from aegis_research import AegisResearch

async def batch_research():
    client = AegisResearch(api_key="your_api_key")

    topics = [
        "Python async best practices",
        "FastAPI vs Flask comparison",
        "SQLAlchemy 2.0 migration guide"
    ]

    # Run research in parallel
    tasks = [client.research_async(topic) for topic in topics]
    results = await asyncio.gather(*tasks)

    for topic, result in zip(topics, results):
        print(f"\n{topic}:")
        print(result.summary[:200] + "...")

asyncio.run(batch_research())

from aegis_research import (
    AegisResearch,
    AuthenticationError,
    RateLimitError,
    InsufficientCreditsError,
    ResearchError
)

client = AegisResearch(api_key="your_api_key")

try:
    result = client.research("My research topic")
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after: {e.retry_after}s")
except InsufficientCreditsError:
    print("Out of credits. Upgrade your plan.")
except ResearchError as e:
    print(f"Research failed: {e}")

def create_content_brief(topic: str) -> dict:
    """Generate a content research brief for writers."""
    client = AegisResearch(api_key="your_api_key")

    result = client.research(
        f"Comprehensive guide to {topic}: key concepts, best practices, common mistakes",
        depth=ResearchDepth.DEEP
    )

    return {
        "topic": topic,
        "overview": result.summary,
        "key_points": result.key_findings,
        "detailed_research": result.detailed_analysis,
        "reference_sources": [
            {"title": s.title, "url": s.url}
            for s in result.sources
        ]
    }

async def analyze_competitors(company: str, competitors: list[str]) -> dict:
    """Research a company and its competitors."""
    client = AegisResearch(api_key="your_api_key")

    # Research all in parallel
    queries = [
        f"{company} products features pricing market position",
        *[f"{c} products features pricing comparison to {company}" for c in competitors]
    ]

    tasks = [client.research_async(q, depth=ResearchDepth.MEDIUM) for q in queries]
    results = await asyncio.gather(*tasks)

    return {
        "company": {
            "name": company,
            "research": results[0].summary,
            "key_findings": results[0].key_findings
        },
        "competitors": [
            {
                "name": c,
                "research": r.summary,
                "differentiators": r.key_findings
            }
            for c, r in zip(competitors, results[1:])
        ]
    }

def compare_technologies(options: list[str], criteria: str) -> dict:
    """Compare technology options for a decision."""
    client = AegisResearch(api_key="your_api_key")

    query = f"Compare {', '.join(options)} for {criteria}. Include pros, cons, and recommendations."
    result = client.research(query, depth=ResearchDepth.DEEP)

    return {
        "comparison": result.summary,
        "key_factors": result.key_findings,
        "detailed_analysis": result.detailed_analysis,
        "sources": len(result.sources),
        "credits_used": result.credits_used
    }

# Usage
decision = compare_technologies(
    options=["PostgreSQL", "MongoDB", "DynamoDB"],
    criteria="high-traffic e-commerce application with complex queries"
)

client = AegisResearch(
    api_key="your_api_key",
    base_url="https://aegisagent.ai/api/v1/research",  # Default
    timeout=60.0  # Request timeout in seconds
)