# Quick Start Guide

### 🚀 Your First Agent in 5 Minutes

Welcome to DeepCore! This guide will help you create your first AI agent in just a few minutes. Let's get started!

#### Prerequisites

Before you begin, make sure you have:

* `Python 3.11+`
* `pip or poetry`
* `Basic understanding of Python`
* `An API key for your preferred AI model (e.g., OpenAI, Claude)`

#### Installation

{% code overflow="wrap" %}

```
# Using pip
pip install deepcore
​
# Or using poetry
poetry add deepcore
```

{% endcode %}

#### 1. Create Your First Agent

```
from deepcore import Agent
​
# Initialize a simple agent
agent = Agent(
    name="my_first_agent",
    description="A helpful assistant",
    model="gpt-4"  # or any other supported model
)
​
# Start a conversation
response = agent.chat("Hello! Can you help me with some data analysis?")
print(response)
```

#### 2. Add Tools to Your Agent

```
from deepcore.tools import Calculator, WebSearch
​
# Create an agent with tools
agent = Agent(
    name="powered_agent",
    description="An agent that can calculate and search",
    model="gpt-4",
    tools=[Calculator(), WebSearch()]
)
​
# Ask the agent to use tools
response = agent.chat("What is the square root of 144 plus the current temperature in New York?")
print(response)
```

#### 3. Create a Custom Tool

```
from deepcore.tools import BaseTool
​
class WeatherTool(BaseTool):
    def __init__(self):
        super().__init__(
            name="weather",
            description="Get weather information"
        )
    
    async def _run(self, location: str) -> str:
        # Implement weather checking logic
        return f"Weather information for {location}"
​
# Use your custom tool
agent = Agent(
    name="weather_agent",
    tools=[WeatherTool()]
)
```

#### 4. Multi-Agent Collaboration

```
from deepcore import Agent, Team
​
# Create specialized agents
researcher = Agent(name="researcher", tools=["web_search"])
analyst = Agent(name="analyst", tools=["calculator"])
writer = Agent(name="writer", tools=["text_processor"])
​
# Create a team
team = Team(
    name="research_team",
    agents=[researcher, analyst, writer]
)
​
# Let the team work together
result = team.collaborate("Research the impact of AI on healthcare and prepare a report")
```

#### 5. Deploy Your Agent

```
from deepcore.deploy import APIServer
​
# Create an API server
server = APIServer(agents=[agent])
​
# Start the server
server.run(host="localhost", port=8000)
```

Now your agent is accessible via REST API:

```
curl -X POST http://localhost:8000/chat \
    -H "Content-Type: application/json" \
    -d '{"message": "Hello, agent!"}'
```

### Next Steps

#### Explore More Features

* Add memory to your agents
* Implement custom workflows
* Create agent teams
* Add authentication
* Monitor performance

#### Advanced Topics

* Custom model integration
* Advanced tool development
* Multi-agent orchestration
* Performance optimization
* Security implementation

#### Best Practices

1. Always handle errors gracefully
2. Monitor agent performance
3. Implement rate limiting
4. Secure sensitive information
5. Test thoroughly

### Common Use Cases

#### Customer Service

```
service_agent = Agent(
    name="customer_service",
    description="Helpful customer service agent",
    tools=["faq", "ticket_system", "email"]
)
```

#### Data Analysis

```
analysis_agent = Agent(
    name="data_analyst",
    description="Data analysis specialist",
    tools=["pandas", "matplotlib", "database"]
)
```

#### Content Creation

```
content_agent = Agent(
    name="content_creator",
    description="Creative content writer",
    tools=["text_generator", "image_creator"]
)
```

### Troubleshooting

#### Common Issues

1. Model API Issues

```
# Implement fallback
agent = Agent(
    name="reliable_agent",
    model="gpt-4",
    fallback_model="gpt-3.5-turbo"
)
```

2. Rate Limiting

```
# Implement rate limiting
agent = Agent(
    name="controlled_agent",
    rate_limit=10,  # requests per minute
    rate_limit_period=60
)
```

3. Memory Issues

```
# Manage memory
agent = Agent(
    name="memory_efficient",
    max_memory_tokens=1000,
    memory_type="sliding_window"
)
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.deepcore.top/developer-guide/integrations.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.