> For the complete documentation index, see [llms.txt](https://docs.deepcore.top/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.deepcore.top/developer-guide/integrations.md).

# 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.