klas/t6_mem0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Mintlify documentation for Phase 2 completion

Browse Source 
📚 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
Download Patch File Download Diff File Expand all files Collapse all files

17
docs/introduction.mdx
View File

@@ -41,11 +41,11 @@ The Mem0 Memory System is a comprehensive, self-hosted memory layer designed for
Advanced relationship mapping with Neo4j for contextual memory connections
</Card>
<Card
title="MCP Integration"
icon="link"
href="/guides/mcp-integration"
title="REST API Server ✅"
icon="code"
href="/open-source/features/rest-api"
>
Model Context Protocol server for Claude Code and other AI tools
Production-ready FastAPI server with authentication, rate limiting, and comprehensive testing
</Card>
</CardGroup>
@@ -64,8 +64,8 @@ The Mem0 Memory System is a comprehensive, self-hosted memory layer designed for
Full Ollama integration with 20+ local models including Llama, Qwen, and specialized embedding models.
</Accordion>
<Accordion title="API-First Design">
RESTful API with comprehensive memory operations, authentication, and rate limiting.
<Accordion title="REST API Complete ✅">
Production-ready FastAPI server with comprehensive memory operations, authentication, rate limiting, and testing suites.
</Accordion>
<Accordion title="Self-Hosted Privacy">
@@ -89,10 +89,10 @@ graph TB
G --> I[OpenAI/Remote]
```
## Current Status: Phase 1 Complete ✅
## Current Status: Phase 2 Complete ✅
<Note>
**Foundation Ready**: All core infrastructure components are operational and tested.
**REST API Ready**: Complete FastAPI implementation with authentication, testing, and documentation.
</Note>
| Component | Status | Description |
@@ -101,6 +101,7 @@ graph TB
| **Supabase** | ✅ Ready | Self-hosted database with pgvector on localhost:8000 |
| **Ollama** | ✅ Ready | 21+ local models available on localhost:11434 |
| **Mem0 Core** | ✅ Ready | Memory management system v0.1.115 |
| **REST API** | ✅ Ready | FastAPI server with full CRUD, auth, and testing on localhost:8080 |
## Getting Started

227
docs/open-source/features/rest-api.mdx
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)

27
docs/quickstart.mdx
View File

@@ -32,4 +32,29 @@ Supabase is already running as part of your existing infrastructure on the local
python test_all_connections.py
```
You should see all systems passing.
You should see all systems passing.
### Step 3: Start the REST API Server ✅
Our Phase 2 implementation provides a production-ready REST API:
```bash
python start_api.py
```
The server will start on **http://localhost:8080** with:
- Interactive documentation at `/docs`
- Full authentication and rate limiting
- Comprehensive error handling
### Step 4: Test the API
Run our test suite to verify everything works:
```bash
# Quick validation test
python test_api_simple.py
# Comprehensive test suite
python test_api.py
```