IdeaDog Academic Idea Generator

An AI multi-agent system for generating scientific research ideas by combining insights from different academic domains.

What This Skill Does

This skill configures GitHub Copilot to assist with building and extending a Python-based academic idea proposal system using LangGraph. The system uses multiple agents to search research threads and synthesize A+B type interdisciplinary research proposals.

Technical Stack

Code Style & Conventions

Type Safety

Python Standards

Error Handling

Project Structure

```

/agents/ # Individual agent implementations

/tools/ # External API integrations (arXiv, Google Scholar)

/models/ # Data models and state definitions

/utils/ # Helper functions and utilities

```

Key Development Patterns

LangGraph Architecture

1. Use StateGraph for building agent workflows

2. Implement proper state management with TypedDict

3. Use the `add_messages` pattern for state updates

4. Create modular agents that compose into larger workflows

API Integration

1. Store API keys in environment variables

2. Implement rate limiting for all external API calls

3. Add retry logic with exponential backoff

4. Cache responses where appropriate

Code Quality

1. Write modular, testable functions

2. Create comprehensive logging for debugging

3. Consider performance implications of concurrent operations

4. Avoid blocking operations in async contexts

Development Guidelines

When Creating New Agents

```python

from typing import TypedDict, Annotated

from langchain_core.messages import BaseMessage

class AgentState(TypedDict):

"""State definition with proper typing"""

messages: Annotated[list[BaseMessage], add_messages]

# Additional fields...

async def agent_function(state: AgentState) -> AgentState:

"""

Clear description of agent purpose.

Args:

state: Current workflow state

Returns:

Updated state with new messages/data

"""

# Implementation with error handling

pass

```

When Integrating APIs

```python

import os

from typing import Optional

import asyncio

class ExternalAPIClient:

"""Client for [API Name] with rate limiting."""

def __init__(self):

self.api_key = os.getenv('API_KEY_NAME')

self.rate_limiter = RateLimiter(calls=10, period=60)

async def fetch_data(self, query: str) -> Optional[dict]:

"""Fetch data with error handling and rate limiting."""

try:

await self.rate_limiter.wait()

# API call implementation

except Exception as e:

logger.error(f"API call failed: {e}")

return None

```

Best Practices

1. **Security:** Never hardcode API keys; always use environment variables

2. **Performance:** Use asyncio.gather() for concurrent API calls

3. **Debugging:** Add structured logging with appropriate levels

4. **Testing:** Write unit tests for all agent logic

5. **Documentation:** Update docstrings when modifying function signatures

Example Usage

When asking Copilot for help:

Constraints