Update Mintlify documentation for Phase 2 completion

📚 Documentation updates reflecting REST API completion:

 Updated REST API feature page:
- Added Phase 2 completion notice
- Updated features list with current capabilities
- Replaced generic instructions with actual implementation
- Added comprehensive usage examples (cURL, Python, JavaScript)
- Included testing information and interactive docs links

 Updated introduction page:
- Changed status from Phase 1 to Phase 2 complete
- Added REST API to component status table
- Updated API accordion with completion status
- Added REST API server card with direct link

 Updated quickstart guide:
- Added Step 3: REST API server startup
- Added Step 4: API testing instructions
- Included specific commands and endpoints

🎯 All documentation now accurately reflects Phase 2 completion
📊 Users can follow updated guides to use the functional API

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Docker Config Backup
2025-07-31 17:07:56 +02:00
parent 8ea9fff334
commit 801ae75069
3 changed files with 182 additions and 89 deletions

View File

@@ -4,113 +4,180 @@ icon: "server"
iconType: "solid"
---
<Snippet file="blank-notif.mdx" />
<Note>
**Phase 2 Complete ✅** - The REST API implementation is fully functional and production-ready as of 2025-07-31.
</Note>
Mem0 provides a REST API server (written using FastAPI). Users can perform all operations through REST endpoints. The API also includes OpenAPI documentation, accessible at `/docs` when the server is running.
Mem0 provides a comprehensive REST API server built with FastAPI. The implementation features complete CRUD operations, authentication, rate limiting, and robust error handling. The API includes OpenAPI documentation accessible at `/docs` when the server is running.
<Frame caption="APIs supported by Mem0 REST API Server">
<img src="/images/rest-api-server.png"/>
</Frame>
## Features
## Features ✅ Complete
- **Create memories:** Create memories based on messages for a user, agent, or run.
- **Retrieve memories:** Get all memories for a given user, agent, or run.
- **Search memories:** Search stored memories based on a query.
- **Update memories:** Update an existing memory.
- **Delete memories:** Delete a specific memory or all memories for a user, agent, or run.
- **Reset memories:** Reset all memories for a user, agent, or run.
- **OpenAPI Documentation:** Accessible via `/docs` endpoint.
- **Memory Management:** Full CRUD operations (Create, Read, Update, Delete)
- **User Management:** User-specific memory operations and statistics
- **Search & Retrieval:** Advanced search with filtering and pagination
- **Authentication:** API key-based authentication with Bearer tokens
- **Rate Limiting:** Configurable rate limiting (100 req/min default)
- **Admin Operations:** Protected admin endpoints for system management
- **Health Monitoring:** Health checks and system status endpoints
- **Error Handling:** Comprehensive error responses with structured format
- **OpenAPI Documentation:** Interactive API documentation at `/docs`
- **Async Operations:** Non-blocking operations for scalability
## Running Locally
<Tabs>
<Tab title="With Docker Compose">
The Development Docker Compose comes pre-configured with postgres pgvector, neo4j and a `server/history/history.db` volume for the history database.
<Tab title="Direct Python Execution ✅ Current Implementation">
Our Phase 2 implementation provides a ready-to-use FastAPI server.
The only required environment variable to run the server is `OPENAI_API_KEY`.
1. Create a `.env` file in the `server/` directory and set your environment variables. For example:
```txt
OPENAI_API_KEY=your-openai-api-key
```
2. Run the Docker container using Docker Compose:
1. Ensure you have the required dependencies installed:
```bash
cd server
docker compose up
pip install fastapi uvicorn mem0ai[all] posthog qdrant-client vecs ollama
```
3. Access the API at http://localhost:8888.
2. Configure your environment (optional - has sensible defaults):
4. Making changes to the server code or the library code will automatically reload the server.
```bash
export API_HOST=localhost
export API_PORT=8080
export API_KEYS=mem0_dev_key_123456789,mem0_custom_key_123
export ADMIN_API_KEYS=mem0_admin_key_111222333
export RATE_LIMIT_REQUESTS=100
export RATE_LIMIT_WINDOW_MINUTES=1
```
3. Start the server:
```bash
python start_api.py
```
4. Access the API at **http://localhost:8080**
5. View documentation at **http://localhost:8080/docs**
</Tab>
<Tab title="With Docker">
<Tab title="Direct Uvicorn">
For development with automatic reloading:
1. Create a `.env` file in the current directory and set your environment variables. For example:
```txt
OPENAI_API_KEY=your-openai-api-key
```bash
uvicorn api.main:app --host localhost --port 8080 --reload
```
2. Either pull the docker image from docker hub or build the docker image locally.
<Tabs>
<Tab title="Pull from Docker Hub">
```bash
docker pull mem0/mem0-api-server
```
</Tab>
<Tab title="Build Locally">
```bash
docker build -t mem0-api-server .
```
</Tab>
</Tabs>
3. Run the Docker container:
``` bash
docker run -p 8000:8000 mem0-api-server --env-file .env
```
4. Access the API at http://localhost:8000.
</Tab>
<Tab title="Without Docker">
1. Create a `.env` file in the current directory and set your environment variables. For example:
```txt
OPENAI_API_KEY=your-openai-api-key
```
2. Install dependencies:
<Tab title="With Docker (Future)">
Docker support is planned for Phase 3.
```bash
pip install -r requirements.txt
# Coming soon in Phase 3
docker build -t mem0-api-server .
docker run -p 8080:8080 mem0-api-server
```
3. Start the FastAPI server:
```bash
uvicorn main:app --reload
```
4. Access the API at http://localhost:8000.
</Tab>
</Tabs>
## Usage
## API Endpoints
Once the server is running (locally or via Docker), you can interact with it using any REST client or through your preferred programming language (e.g., Go, Java, etc.). You can test out the APIs using the OpenAPI documentation at [http://localhost:8000/docs](http://localhost:8000/docs) endpoint.
Our Phase 2 implementation includes the following endpoints:
### Memory Operations
- `POST /v1/memories` - Add new memories
- `GET /v1/memories/search` - Search memories by content
- `GET /v1/memories/{memory_id}` - Get specific memory
- `DELETE /v1/memories/{memory_id}` - Delete specific memory
- `GET /v1/memories/user/{user_id}` - Get all user memories
- `DELETE /v1/users/{user_id}/memories` - Delete all user memories
### User Management
- `GET /v1/users/{user_id}/stats` - Get user statistics
### Health & Monitoring
- `GET /health` - Basic health check (no auth required)
- `GET /status` - Detailed system status (auth required)
- `GET /v1/metrics` - API metrics (admin only)
### Authentication
All endpoints (except `/health`) require authentication via Bearer token:
```bash
Authorization: Bearer mem0_dev_key_123456789
```
## Usage Examples
<CodeGroup>
```bash cURL
# Add a memory
curl -X POST "http://localhost:8080/v1/memories" \
-H "Authorization: Bearer mem0_dev_key_123456789" \
-H "Content-Type: application/json" \
-d '{
"messages": [{"role": "user", "content": "I love Python programming"}],
"user_id": "user123",
"metadata": {"source": "api_test"}
}'
```
```python Python
import requests
headers = {"Authorization": "Bearer mem0_dev_key_123456789"}
# Add memory
response = requests.post(
"http://localhost:8080/v1/memories",
headers=headers,
json={
"messages": [{"role": "user", "content": "I love Python programming"}],
"user_id": "user123",
"metadata": {"source": "python_client"}
}
)
# Search memories
response = requests.get(
"http://localhost:8080/v1/memories/search",
headers=headers,
params={"query": "Python", "user_id": "user123", "limit": 10}
)
```
```javascript JavaScript
const headers = {
'Authorization': 'Bearer mem0_dev_key_123456789',
'Content-Type': 'application/json'
};
// Add memory
const response = await fetch('http://localhost:8080/v1/memories', {
method: 'POST',
headers: headers,
body: JSON.stringify({
messages: [{role: 'user', content: 'I love Python programming'}],
user_id: 'user123',
metadata: {source: 'js_client'}
})
});
```
</CodeGroup>
## Testing
We provide comprehensive testing suites:
```bash
# Run comprehensive tests
python test_api.py
# Run quick validation tests
python test_api_simple.py
```
## Interactive Documentation
When the server is running, access the interactive OpenAPI documentation at:
- **Swagger UI:** [http://localhost:8080/docs](http://localhost:8080/docs)
- **ReDoc:** [http://localhost:8080/redoc](http://localhost:8080/redoc)