diff --git a/.gitignore b/.gitignore
index 5fee1be..16aa11f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,31 @@
-env.py
\ No newline at end of file
+env.py
+
+# Python cache files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
\ No newline at end of file
diff --git a/LLM_Metadata/__pycache__/__init__.cpython-311.pyc b/LLM_Metadata/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index a87435f..0000000
Binary files a/LLM_Metadata/__pycache__/__init__.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/__pycache__/admin.cpython-311.pyc b/LLM_Metadata/__pycache__/admin.cpython-311.pyc
deleted file mode 100644
index c14484e..0000000
Binary files a/LLM_Metadata/__pycache__/admin.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/__pycache__/apps.cpython-311.pyc b/LLM_Metadata/__pycache__/apps.cpython-311.pyc
deleted file mode 100644
index 4c38d7f..0000000
Binary files a/LLM_Metadata/__pycache__/apps.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/__pycache__/forms.cpython-311.pyc b/LLM_Metadata/__pycache__/forms.cpython-311.pyc
deleted file mode 100644
index ab24603..0000000
Binary files a/LLM_Metadata/__pycache__/forms.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/__pycache__/models.cpython-311.pyc b/LLM_Metadata/__pycache__/models.cpython-311.pyc
deleted file mode 100644
index 251bba0..0000000
Binary files a/LLM_Metadata/__pycache__/models.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/__pycache__/urls.cpython-311.pyc b/LLM_Metadata/__pycache__/urls.cpython-311.pyc
deleted file mode 100644
index c5a4a38..0000000
Binary files a/LLM_Metadata/__pycache__/urls.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/__pycache__/utils.cpython-311.pyc b/LLM_Metadata/__pycache__/utils.cpython-311.pyc
deleted file mode 100644
index 3dd5d7b..0000000
Binary files a/LLM_Metadata/__pycache__/utils.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/__pycache__/views.cpython-311.pyc b/LLM_Metadata/__pycache__/views.cpython-311.pyc
deleted file mode 100644
index 75037c6..0000000
Binary files a/LLM_Metadata/__pycache__/views.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/api.py b/LLM_Metadata/api.py
new file mode 100644
index 0000000..5831e8b
--- /dev/null
+++ b/LLM_Metadata/api.py
@@ -0,0 +1,145 @@
+"""
+API views using Django REST Framework with rate limiting and caching
+"""
+from rest_framework.decorators import api_view, throttle_classes
+from rest_framework.response import Response
+from rest_framework.throttling import UserRateThrottle, AnonRateThrottle
+from rest_framework import status
+from django.views.decorators.cache import cache_page
+from django.utils.decorators import method_decorator
+from django.core.cache import cache
+from .models import Conversation
+from django.contrib.auth.decorators import login_required
+from django_ratelimit.decorators import ratelimit
+import uuid
+from django.utils import timezone
+
+
+class ConversationRateThrottle(UserRateThrottle):
+    """Custom throttle for conversation API - 50 requests per hour"""
+    rate = '50/hour'
+
+
+class HealthCheckRateThrottle(AnonRateThrottle):
+    """Custom throttle for health check API - 200 requests per hour"""
+    rate = '200/hour'
+
+
+@api_view(['GET'])
+@throttle_classes([HealthCheckRateThrottle])
+@cache_page(60)  # Cache for 1 minute
+def api_health_check(request):
+    """
+    API endpoint for health check with rate limiting and caching
+    Returns system health status
+    """
+    try:
+        # Test database connection
+        total_conversations = Conversation.objects.count()
+        latest_conversation = Conversation.objects.first()
+        
+        return Response({
+            'status': 'healthy',
+            'timestamp': timezone.now().isoformat(),
+            'database': {
+                'total_conversations': total_conversations,
+                'latest_conversation_date': latest_conversation.timestamp.isoformat() if latest_conversation else None,
+            },
+            'message': 'API is operational'
+        }, status=status.HTTP_200_OK)
+        
+    except Exception as e:
+        return Response({
+            'status': 'error',
+            'error': str(e),
+            'timestamp': timezone.now().isoformat(),
+            'message': 'Database connection failed'
+        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+@api_view(['GET'])
+@throttle_classes([ConversationRateThrottle])
+def api_conversation_stats(request):
+    """
+    API endpoint to get conversation statistics with caching
+    Returns user's conversation count and recent activity
+    """
+    if not request.user.is_authenticated:
+        return Response({
+            'error': 'Authentication required'
+        }, status=status.HTTP_401_UNAUTHORIZED)
+    
+    # Try to get cached data first
+    cache_key = f'conversation_stats_{request.user.id}'
+    cached_data = cache.get(cache_key)
+    
+    if cached_data:
+        cached_data['cached'] = True
+        return Response(cached_data, status=status.HTTP_200_OK)
+    
+    # If not cached, query database
+    user_conversations = Conversation.objects.filter(username=request.user.username)
+    total_count = user_conversations.count()
+    recent_conversations = user_conversations.order_by('-timestamp')[:5]
+    
+    data = {
+        'user': request.user.username,
+        'total_conversations': total_count,
+        'recent_conversations': [
+            {
+                'id': conv.id,
+                'role': conv.role,
+                'content': conv.content[:100] + '...' if len(conv.content) > 100 else conv.content,
+                'timestamp': conv.timestamp.isoformat(),
+                'model_name': conv.model_name,
+            }
+            for conv in recent_conversations
+        ],
+        'cached': False
+    }
+    
+    # Cache the data for 5 minutes
+    cache.set(cache_key, data, 300)
+    
+    return Response(data, status=status.HTTP_200_OK)
+
+
+@api_view(['DELETE'])
+@throttle_classes([ConversationRateThrottle])
+def api_delete_conversation(request, conversation_id):
+    """
+    API endpoint to delete a conversation with rate limiting
+    """
+    if not request.user.is_authenticated:
+        return Response({
+            'error': 'Authentication required'
+        }, status=status.HTTP_401_UNAUTHORIZED)
+    
+    try:
+        # Get conversations with this conversation_id belonging to the user
+        conversations = Conversation.objects.filter(
+            conversation_id=conversation_id,
+            username=request.user.username
+        )
+        
+        if not conversations.exists():
+            return Response({
+                'error': 'Conversation not found or access denied'
+            }, status=status.HTTP_404_NOT_FOUND)
+        
+        count = conversations.count()
+        conversations.delete()
+        
+        # Invalidate cache for this user's stats
+        cache_key = f'conversation_stats_{request.user.id}'
+        cache.delete(cache_key)
+        
+        return Response({
+            'message': f'Successfully deleted {count} conversation entries',
+            'conversation_id': str(conversation_id)
+        }, status=status.HTTP_200_OK)
+        
+    except Exception as e:
+        return Response({
+            'error': str(e)
+        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
diff --git a/LLM_Metadata/templatetags/__pycache__/__init__.cpython-311.pyc b/LLM_Metadata/templatetags/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 4d7635e..0000000
Binary files a/LLM_Metadata/templatetags/__pycache__/__init__.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/templatetags/__pycache__/conversation_filters.cpython-311.pyc b/LLM_Metadata/templatetags/__pycache__/conversation_filters.cpython-311.pyc
deleted file mode 100644
index 9abb2ab..0000000
Binary files a/LLM_Metadata/templatetags/__pycache__/conversation_filters.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/templatetags/__pycache__/custom_filters.cpython-311.pyc b/LLM_Metadata/templatetags/__pycache__/custom_filters.cpython-311.pyc
deleted file mode 100644
index af66be8..0000000
Binary files a/LLM_Metadata/templatetags/__pycache__/custom_filters.cpython-311.pyc and /dev/null differ
diff --git a/LLM_Metadata/test_api.py b/LLM_Metadata/test_api.py
new file mode 100644
index 0000000..a87e981
--- /dev/null
+++ b/LLM_Metadata/test_api.py
@@ -0,0 +1,204 @@
+"""
+Tests for API rate limiting and caching functionality
+"""
+from django.test import TestCase, Client
+from django.contrib.auth.models import User
+from django.core.cache import cache
+from django.urls import reverse
+from LLM_Metadata.models import Conversation
+import uuid
+from django.utils import timezone
+
+
+class RateLimitingTests(TestCase):
+    """Test rate limiting functionality"""
+    
+    def setUp(self):
+        """Set up test client and user"""
+        self.client = Client()
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass123'
+        )
+        self.client.login(username='testuser', password='testpass123')
+        cache.clear()
+    
+    def test_health_check_endpoint_exists(self):
+        """Test that health check endpoint is accessible"""
+        response = self.client.get('/health/')
+        self.assertEqual(response.status_code, 200)
+        self.assertIn('status', response.json())
+    
+    def test_api_health_check_endpoint_exists(self):
+        """Test that API health check endpoint is accessible"""
+        response = self.client.get('/api/health/')
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertIn('status', data)
+        self.assertEqual(data['status'], 'healthy')
+
+
+class CachingTests(TestCase):
+    """Test caching functionality"""
+    
+    def setUp(self):
+        """Set up test client and user"""
+        self.client = Client()
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass123'
+        )
+        self.client.login(username='testuser', password='testpass123')
+        
+        # Create some test conversations
+        for i in range(3):
+            Conversation.objects.create(
+                role='user' if i % 2 == 0 else 'assistant',
+                content=f'Test content {i}',
+                username=self.user.username,
+                conversation_id=uuid.uuid4(),
+                timestamp=timezone.now()
+            )
+        
+        cache.clear()
+    
+    def test_conversation_stats_caching(self):
+        """Test that conversation stats are cached"""
+        # First request - not cached
+        response1 = self.client.get('/api/conversations/stats/')
+        self.assertEqual(response1.status_code, 200)
+        data1 = response1.json()
+        self.assertFalse(data1.get('cached', True))
+        
+        # Second request - should be cached
+        response2 = self.client.get('/api/conversations/stats/')
+        self.assertEqual(response2.status_code, 200)
+        data2 = response2.json()
+        self.assertTrue(data2.get('cached', False))
+        
+        # Data should be the same
+        self.assertEqual(data1['total_conversations'], data2['total_conversations'])
+    
+    def test_cache_invalidation_on_delete(self):
+        """Test that cache is invalidated when conversation is deleted"""
+        # Get initial stats (creates cache)
+        response1 = self.client.get('/api/conversations/stats/')
+        data1 = response1.json()
+        initial_count = data1['total_conversations']
+        
+        # Delete a conversation
+        conversation = Conversation.objects.filter(username=self.user.username).first()
+        response = self.client.delete(
+            f'/api/conversations/{conversation.conversation_id}/'
+        )
+        self.assertEqual(response.status_code, 200)
+        
+        # Get stats again - cache should be invalidated
+        response2 = self.client.get('/api/conversations/stats/')
+        data2 = response2.json()
+        self.assertFalse(data2.get('cached', True))
+        self.assertLess(data2['total_conversations'], initial_count)
+
+
+class APIEndpointsTests(TestCase):
+    """Test API endpoints functionality"""
+    
+    def setUp(self):
+        """Set up test client and user"""
+        self.client = Client()
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass123'
+        )
+        self.conversation_id = uuid.uuid4()
+        
+        # Create test conversations
+        Conversation.objects.create(
+            role='user',
+            content='Test question',
+            username=self.user.username,
+            conversation_id=self.conversation_id,
+            timestamp=timezone.now()
+        )
+        Conversation.objects.create(
+            role='assistant',
+            content='Test response',
+            username=self.user.username,
+            conversation_id=self.conversation_id,
+            timestamp=timezone.now()
+        )
+        
+        cache.clear()
+    
+    def test_conversation_stats_requires_authentication(self):
+        """Test that conversation stats endpoint requires authentication"""
+        response = self.client.get('/api/conversations/stats/')
+        self.assertEqual(response.status_code, 401)
+    
+    def test_conversation_stats_returns_correct_data(self):
+        """Test that conversation stats returns correct data"""
+        self.client.login(username='testuser', password='testpass123')
+        response = self.client.get('/api/conversations/stats/')
+        self.assertEqual(response.status_code, 200)
+        
+        data = response.json()
+        self.assertEqual(data['user'], 'testuser')
+        self.assertEqual(data['total_conversations'], 2)
+        self.assertIsInstance(data['recent_conversations'], list)
+    
+    def test_delete_conversation_api(self):
+        """Test deleting conversation via API"""
+        self.client.login(username='testuser', password='testpass123')
+        
+        # Delete conversation
+        response = self.client.delete(
+            f'/api/conversations/{self.conversation_id}/'
+        )
+        self.assertEqual(response.status_code, 200)
+        
+        data = response.json()
+        self.assertIn('message', data)
+        self.assertEqual(data['conversation_id'], str(self.conversation_id))
+        
+        # Verify conversations are deleted
+        remaining = Conversation.objects.filter(
+            conversation_id=self.conversation_id
+        ).count()
+        self.assertEqual(remaining, 0)
+    
+    def test_delete_nonexistent_conversation(self):
+        """Test deleting a conversation that doesn't exist"""
+        self.client.login(username='testuser', password='testpass123')
+        
+        fake_uuid = uuid.uuid4()
+        response = self.client.delete(f'/api/conversations/{fake_uuid}/')
+        self.assertEqual(response.status_code, 404)
+    
+    def test_delete_conversation_requires_authentication(self):
+        """Test that delete requires authentication"""
+        response = self.client.delete(
+            f'/api/conversations/{self.conversation_id}/'
+        )
+        self.assertEqual(response.status_code, 401)
+
+
+class SettingsTests(TestCase):
+    """Test that settings are configured correctly"""
+    
+    def test_rest_framework_configured(self):
+        """Test that REST framework is configured"""
+        from django.conf import settings
+        self.assertIn('rest_framework', settings.INSTALLED_APPS)
+        self.assertIn('DEFAULT_THROTTLE_CLASSES', settings.REST_FRAMEWORK)
+    
+    def test_cache_configured(self):
+        """Test that cache is configured"""
+        from django.conf import settings
+        self.assertIn('default', settings.CACHES)
+        self.assertIn('BACKEND', settings.CACHES['default'])
+    
+    def test_ratelimit_configured(self):
+        """Test that rate limiting is configured"""
+        from django.conf import settings
+        self.assertTrue(hasattr(settings, 'RATELIMIT_ENABLE'))
+        self.assertTrue(hasattr(settings, 'RATELIMIT_USE_CACHE'))
diff --git a/LLM_Metadata/urls.py b/LLM_Metadata/urls.py
index ff2b9d1..1642b3c 100644
--- a/LLM_Metadata/urls.py
+++ b/LLM_Metadata/urls.py
@@ -1,5 +1,6 @@
 from django.urls import path
 from . import views
+from . import api
 
 urlpatterns = [
     path('', views.home, name='home'),
@@ -7,6 +8,11 @@
     # path('delete_conversation/<uuid:conversation_id>/', views.delete_conversation, name='delete_conversation'),
     path('ask/', views.ask_question_view, name='ask_question'),
     path('json-viewer/', views.json_viewer, name='json_viewer'),
-        path('delete_conversation/<int:user_convo_id>/', views.delete_conversation, name='delete_conversation'),
+    path('delete_conversation/<int:user_convo_id>/', views.delete_conversation, name='delete_conversation'),
     path('health/', views.health_check, name='health_check'),
+    
+    # API endpoints with rate limiting and caching
+    path('api/health/', api.api_health_check, name='api_health_check'),
+    path('api/conversations/stats/', api.api_conversation_stats, name='api_conversation_stats'),
+    path('api/conversations/<uuid:conversation_id>/', api.api_delete_conversation, name='api_delete_conversation'),
 ]
diff --git a/LLM_Metadata/views.py b/LLM_Metadata/views.py
index 2dda335..8c355e8 100644
--- a/LLM_Metadata/views.py
+++ b/LLM_Metadata/views.py
@@ -15,6 +15,8 @@
 from django.views.decorators.csrf import csrf_exempt
 from django.views.decorators.http import require_http_methods
 from django.db import connection
+from django.views.decorators.cache import cache_page
+from django_ratelimit.decorators import ratelimit
 
 def home(request):
     
@@ -22,6 +24,7 @@ def home(request):
 
 
 @login_required
+@ratelimit(key='user', rate='100/h', method='POST', block=True)
 def conversation_view(request):
     if request.method == 'POST':
         form = ConversationForm(request.POST)
@@ -69,6 +72,7 @@ def conversation_view(request):
 
 
 @login_required
+@ratelimit(key='user', rate='50/h', method='POST', block=True)
 def ask_question_view(request):
     # Only clear the conversation when a fresh GET request is made (i.e., the user is revisiting)
     if request.method == 'GET':
@@ -158,6 +162,7 @@ def ask_question_view(request):
     })
 
 
+@ratelimit(key='ip', rate='50/h', method='POST', block=True)
 def json_viewer(request):
     context = {}
 
@@ -181,6 +186,7 @@ def json_viewer(request):
     return render(request, 'LLM_Metadata/json_viewer.html', context)
 
 
+@ratelimit(key='user', rate='30/h', method='POST', block=True)
 def delete_conversation(request, user_convo_id):
     if request.method == 'POST':
         # Get the user conversation and delete it
@@ -197,6 +203,8 @@ def delete_conversation(request, user_convo_id):
 
 @csrf_exempt
 @require_http_methods(["GET", "POST"])
+@ratelimit(key='ip', rate='200/h', method='ALL', block=True)
+@cache_page(60)  # Cache for 1 minute
 def health_check(request):
     """
     Enhanced health check endpoint that performs database operations
diff --git a/QUICK_START.md b/QUICK_START.md
new file mode 100644
index 0000000..327309f
--- /dev/null
+++ b/QUICK_START.md
@@ -0,0 +1,297 @@
+# Quick Start Guide: Rate Limiting and Caching
+
+This guide will help you quickly get started with the rate limiting and caching features.
+
+## 🚀 Quick Setup (5 minutes)
+
+### Step 1: Install Dependencies
+
+```bash
+pip install djangorestframework==3.16.1 django-ratelimit==4.1.0 redis==7.0.1
+```
+
+Or install from the requirements file:
+```bash
+pip install -r requirements_api.txt
+```
+
+### Step 2: Verify Configuration
+
+The configuration is already set up in `main/settings.py`. No changes needed for local development!
+
+✅ Cache backend: Local memory (default)
+✅ Rate limiting: Enabled
+✅ REST Framework: Configured
+
+### Step 3: Run Migrations
+
+```bash
+python manage.py migrate
+```
+
+### Step 4: Start the Server
+
+```bash
+python manage.py runserver
+```
+
+### Step 5: Test the API
+
+Open a new terminal and run:
+```bash
+python example_api_usage.py
+```
+
+You should see:
+```
+✓ Health check working
+✓ Caching enabled (faster responses)
+✓ Rate limiting active (protects from abuse)
+```
+
+## 📊 Available Endpoints
+
+### 1. Health Check (Public)
+```bash
+curl http://localhost:8000/api/health/
+```
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "timestamp": "2024-01-01T00:00:00Z",
+  "database": {
+    "total_conversations": 100
+  }
+}
+```
+
+**Features:**
+- Rate limit: 200 requests/hour per IP
+- Cached for 1 minute
+- No authentication required
+
+### 2. Conversation Statistics (Authenticated)
+```bash
+curl -H "Authorization: Bearer YOUR_TOKEN" \
+     http://localhost:8000/api/conversations/stats/
+```
+
+**Response:**
+```json
+{
+  "user": "username",
+  "total_conversations": 50,
+  "recent_conversations": [...],
+  "cached": false
+}
+```
+
+**Features:**
+- Rate limit: 50 requests/hour per user
+- Cached for 5 minutes per user
+- Requires authentication
+
+### 3. Delete Conversation (Authenticated)
+```bash
+curl -X DELETE \
+     -H "Authorization: Bearer YOUR_TOKEN" \
+     http://localhost:8000/api/conversations/<uuid>/
+```
+
+**Features:**
+- Rate limit: 50 requests/hour per user
+- Invalidates cache automatically
+- Requires authentication
+
+## 🧪 Testing
+
+Run the test suite:
+```bash
+python manage.py test LLM_Metadata.test_api
+```
+
+Expected output:
+```
+Ran 12 tests in 3.0s
+OK
+```
+
+## 🔒 Rate Limit Examples
+
+### Example 1: Normal Usage
+```python
+import requests
+
+# First 50 requests work fine
+for i in range(50):
+    response = requests.get('http://localhost:8000/api/health/')
+    print(f"Request {i+1}: {response.status_code}")
+```
+
+### Example 2: Rate Limit Exceeded
+```python
+# After 200 requests in an hour:
+response = requests.get('http://localhost:8000/api/health/')
+# Status: 429 Too Many Requests
+```
+
+## ⚡ Caching Examples
+
+### Example 1: First Request (Not Cached)
+```python
+import requests
+import time
+
+start = time.time()
+response = requests.get('http://localhost:8000/api/health/')
+duration = time.time() - start
+print(f"First request: {duration*1000:.2f}ms")
+# Output: ~100ms
+```
+
+### Example 2: Second Request (Cached)
+```python
+start = time.time()
+response = requests.get('http://localhost:8000/api/health/')
+duration = time.time() - start
+print(f"Cached request: {duration*1000:.2f}ms")
+# Output: ~5ms (20x faster!)
+```
+
+## 🌍 Production Setup
+
+### For Heroku with Redis
+
+1. Add Redis addon:
+```bash
+heroku addons:create heroku-redis:mini
+```
+
+2. Update `settings.py` (uncomment Redis configuration):
+```python
+CACHES = {
+    'default': {
+        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
+        'LOCATION': os.environ.get('REDIS_URL'),
+    }
+}
+```
+
+3. Deploy:
+```bash
+git push heroku main
+```
+
+### Environment Variables
+
+Required in production:
+```bash
+SECRET_KEY=your-secret-key
+DATABASE_URL=your-database-url
+REDIS_URL=redis://your-redis-host:6379/1  # Optional, for Redis cache
+```
+
+## 📈 Monitoring
+
+### Check Cache Statistics
+
+```python
+from django.core.cache import cache
+
+# Get a cached value
+stats = cache.get('conversation_stats_1')
+
+# Clear cache
+cache.clear()
+
+# Set custom cache
+cache.set('my_key', 'my_value', timeout=300)
+```
+
+### Monitor Rate Limits
+
+Check server logs for rate limit hits:
+```bash
+tail -f logs/django.log | grep "rate limit"
+```
+
+## 🛠️ Customization
+
+### Adjust Rate Limits
+
+Edit `settings.py`:
+```python
+REST_FRAMEWORK = {
+    'DEFAULT_THROTTLE_RATES': {
+        'anon': '200/hour',  # Change this
+        'user': '2000/hour',  # Change this
+    }
+}
+```
+
+### Adjust Cache Timeout
+
+Edit `settings.py`:
+```python
+CACHES = {
+    'default': {
+        'TIMEOUT': 600,  # 10 minutes instead of 5
+    }
+}
+```
+
+### Disable Rate Limiting (Development Only)
+
+Edit `settings.py`:
+```python
+RATELIMIT_ENABLE = False  # Disable for testing
+```
+
+## 🔍 Troubleshooting
+
+### Issue: "Too Many Requests" Error
+
+**Solution:** Wait for the rate limit window to reset (1 hour) or increase limits in settings.
+
+### Issue: Cache Not Working
+
+**Check:**
+1. Is cache backend configured correctly?
+2. Is Redis running (if using Redis)?
+3. Clear cache: `python manage.py shell -c "from django.core.cache import cache; cache.clear()"`
+
+### Issue: Slow Responses Even with Cache
+
+**Check:**
+1. Verify cache is being used (check `cached` field in response)
+2. Check Redis connection (if using Redis)
+3. Monitor database queries with Django Debug Toolbar
+
+## 📚 Next Steps
+
+1. Read full documentation: `RATE_LIMITING_AND_CACHING.md`
+2. Explore the API in your browser: http://localhost:8000/api/
+3. Integrate with your frontend application
+4. Set up Redis for production
+5. Monitor and optimize based on usage patterns
+
+## 💡 Tips
+
+1. **Use caching for read-heavy endpoints** - Statistics, dashboards, reports
+2. **Invalidate cache on writes** - Update, create, delete operations
+3. **Set appropriate TTLs** - Balance freshness vs performance
+4. **Monitor rate limits** - Adjust based on actual usage patterns
+5. **Use Redis in production** - Much better than local memory cache
+
+## 🆘 Getting Help
+
+- 📖 Full documentation: `RATE_LIMITING_AND_CACHING.md`
+- 🧪 Test examples: `LLM_Metadata/test_api.py`
+- 💻 Usage examples: `example_api_usage.py`
+- 📧 Support: amirhossein.bayani@gmail.com
+
+---
+
+**You're all set! The API is now protected with rate limiting and optimized with caching. 🎉**
diff --git a/RATE_LIMITING_AND_CACHING.md b/RATE_LIMITING_AND_CACHING.md
new file mode 100644
index 0000000..6a1f9b5
--- /dev/null
+++ b/RATE_LIMITING_AND_CACHING.md
@@ -0,0 +1,294 @@
+# API Rate Limiting and Caching Implementation
+
+This document describes the rate limiting and caching implementation for the LLM Metadata Django App API.
+
+## Overview
+
+The application now includes:
+1. **Rate Limiting** - Controls the number of requests users can make to API endpoints
+2. **Caching** - Stores frequently accessed data to improve performance
+3. **REST API Endpoints** - Clean API endpoints with proper throttling and caching
+
+## Features Implemented
+
+### 1. Rate Limiting
+
+Rate limiting is implemented using two approaches:
+
+#### A. Django REST Framework Throttling
+Configured in `settings.py`:
+```python
+REST_FRAMEWORK = {
+    'DEFAULT_THROTTLE_CLASSES': [
+        'rest_framework.throttling.AnonRateThrottle',
+        'rest_framework.throttling.UserRateThrottle'
+    ],
+    'DEFAULT_THROTTLE_RATES': {
+        'anon': '100/hour',  # Anonymous users: 100 requests per hour
+        'user': '1000/hour',  # Authenticated users: 1000 requests per hour
+    }
+}
+```
+
+#### B. Django-Ratelimit Decorators
+Applied to individual views:
+- `ask_question_view`: 50 requests/hour per user
+- `conversation_view`: 100 requests/hour per user
+- `health_check`: 200 requests/hour per IP
+- `json_viewer`: 50 requests/hour per IP
+- `delete_conversation`: 30 requests/hour per user
+
+### 2. Caching Configuration
+
+Two caching backends are supported:
+
+#### A. Local Memory Cache (Default for Development)
+```python
+CACHES = {
+    'default': {
+        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
+        'LOCATION': 'unique-snowflake',
+        'TIMEOUT': 300,  # 5 minutes
+        'OPTIONS': {
+            'MAX_ENTRIES': 1000
+        }
+    }
+}
+```
+
+#### B. Redis Cache (Recommended for Production)
+Uncomment and configure in `settings.py`:
+```python
+CACHES = {
+    'default': {
+        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
+        'LOCATION': os.environ.get('REDIS_URL', 'redis://127.0.0.1:6379/1'),
+        'TIMEOUT': 300,
+    }
+}
+```
+
+### 3. API Endpoints
+
+New REST API endpoints in `LLM_Metadata/api.py`:
+
+#### `/api/health/`
+- **Method**: GET
+- **Rate Limit**: 200 requests/hour (IP-based)
+- **Cache**: 1 minute
+- **Description**: Health check endpoint with database connectivity test
+- **Response**:
+  ```json
+  {
+    "status": "healthy",
+    "timestamp": "2024-01-01T00:00:00Z",
+    "database": {
+      "total_conversations": 100,
+      "latest_conversation_date": "2024-01-01T00:00:00Z"
+    },
+    "message": "API is operational"
+  }
+  ```
+
+#### `/api/conversations/stats/`
+- **Method**: GET
+- **Rate Limit**: 50 requests/hour (user-based)
+- **Cache**: 5 minutes (per user)
+- **Authentication**: Required
+- **Description**: Returns conversation statistics for the authenticated user
+- **Response**:
+  ```json
+  {
+    "user": "username",
+    "total_conversations": 50,
+    "recent_conversations": [...],
+    "cached": false
+  }
+  ```
+
+#### `/api/conversations/<uuid:conversation_id>/`
+- **Method**: DELETE
+- **Rate Limit**: 50 requests/hour (user-based)
+- **Authentication**: Required
+- **Description**: Deletes a conversation by UUID
+- **Response**:
+  ```json
+  {
+    "message": "Successfully deleted 2 conversation entries",
+    "conversation_id": "uuid-here"
+  }
+  ```
+
+## Rate Limiting Details
+
+### Per-Endpoint Limits
+
+| Endpoint | Method | Rate Limit | Key |
+|----------|--------|-----------|-----|
+| `/ask/` | POST | 50/hour | User |
+| `/conversation/` | POST | 100/hour | User |
+| `/health/` | GET/POST | 200/hour | IP |
+| `/json-viewer/` | POST | 50/hour | IP |
+| `/delete_conversation/<id>/` | POST | 30/hour | User |
+| `/api/health/` | GET | 200/hour | IP |
+| `/api/conversations/stats/` | GET | 50/hour | User |
+| `/api/conversations/<uuid>/` | DELETE | 50/hour | User |
+
+### Rate Limit Responses
+
+When a rate limit is exceeded, the user receives a 429 Too Many Requests response:
+```json
+{
+    "detail": "Request was throttled. Expected available in X seconds."
+}
+```
+
+## Caching Strategy
+
+### Cached Data
+
+1. **Health Check Endpoint**: Cached for 1 minute to reduce database load
+2. **Conversation Statistics**: Cached for 5 minutes per user
+3. **Cache Invalidation**: Automatically invalidated when:
+   - User creates a new conversation
+   - User deletes a conversation
+
+### Cache Keys
+
+- Health check: Based on URL
+- User stats: `conversation_stats_{user_id}`
+
+## Configuration
+
+### Environment Variables
+
+Required environment variables:
+- `SECRET_KEY`: Django secret key
+- `DATABASE_URL`: Database connection string
+- `REDIS_URL`: (Optional) Redis connection string for caching
+
+### Enable/Disable Rate Limiting
+
+To disable rate limiting (e.g., in development):
+```python
+# In settings.py
+RATELIMIT_ENABLE = False
+```
+
+## Testing
+
+### Test Rate Limiting
+
+1. Make multiple rapid requests to an endpoint:
+   ```bash
+   for i in {1..60}; do
+     curl -X POST http://localhost:8000/ask/ \
+       -H "Authorization: Bearer <token>" \
+       -d "question=test"
+   done
+   ```
+
+2. After 50 requests, you should receive a 429 response
+
+### Test Caching
+
+1. First request to `/api/conversations/stats/`:
+   - Response includes `"cached": false`
+   - Query time: ~100ms
+
+2. Subsequent requests within 5 minutes:
+   - Response includes `"cached": true`
+   - Query time: ~5ms
+
+## Production Deployment
+
+### Using Redis (Recommended)
+
+1. Install Redis:
+   ```bash
+   # Ubuntu/Debian
+   sudo apt-get install redis-server
+   
+   # macOS
+   brew install redis
+   ```
+
+2. Update `settings.py`:
+   ```python
+   CACHES = {
+       'default': {
+           'BACKEND': 'django.core.cache.backends.redis.RedisCache',
+           'LOCATION': os.environ.get('REDIS_URL', 'redis://127.0.0.1:6379/1'),
+       }
+   }
+   ```
+
+3. Set environment variable:
+   ```bash
+   export REDIS_URL='redis://your-redis-host:6379/1'
+   ```
+
+### Monitoring
+
+Monitor rate limiting and caching:
+```python
+from django.core.cache import cache
+
+# Check cache statistics
+cache_keys = cache.keys('*')  # Redis only
+print(f"Total cached items: {len(cache_keys)}")
+```
+
+## Dependencies
+
+New dependencies added (see `requirements_api.txt`):
+- `djangorestframework==3.16.1` - REST API framework
+- `django-ratelimit==4.1.0` - Rate limiting decorator
+- `redis==7.0.1` - Redis client (optional, for production caching)
+
+## Security Considerations
+
+1. **Rate Limiting**: Protects against:
+   - DDoS attacks
+   - Brute force attempts
+   - API abuse
+
+2. **Caching**: 
+   - User-specific data is cached with user-specific keys
+   - Cache invalidation ensures data consistency
+   - Sensitive data is not cached
+
+3. **Authentication**:
+   - API endpoints require authentication where appropriate
+   - Anonymous users have stricter rate limits
+
+## Future Enhancements
+
+1. **Dynamic Rate Limits**: Adjust limits based on user tier/subscription
+2. **Cache Warming**: Pre-populate cache with frequently accessed data
+3. **Rate Limit Analytics**: Track and analyze rate limit hits
+4. **Custom Throttle Classes**: Create more sophisticated throttling strategies
+5. **CDN Integration**: Integrate with CDN for static asset caching
+
+## Troubleshooting
+
+### Rate Limit Not Working
+- Check `RATELIMIT_ENABLE = True` in settings
+- Verify decorators are properly applied to views
+- Check cache backend is working
+
+### Cache Not Working
+- Verify cache backend configuration
+- Check Redis connection (if using Redis)
+- Clear cache: `python manage.py shell -c "from django.core.cache import cache; cache.clear()"`
+
+### 429 Too Many Requests
+- Wait for the rate limit window to reset
+- Check rate limit configuration
+- Contact administrator to increase limits if needed
+
+## References
+
+- [Django REST Framework Throttling](https://www.django-rest-framework.org/api-guide/throttling/)
+- [Django Caching Documentation](https://docs.djangoproject.com/en/4.2/topics/cache/)
+- [django-ratelimit Documentation](https://django-ratelimit.readthedocs.io/)
diff --git a/README.md b/README.md
index cd8926e..a4264bf 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,9 @@ Live webpage: [LLM_Django_app](https://llm-metadata-django-app-835bc5e9a972.hero
 - **Admin Interface**: Django admin panel for managing conversations and metadata
 - **JSON Viewer**: Built-in JSON file viewer and table display functionality
 - **Responsive Design**: Clean, user-friendly interface
+- **🆕 Rate Limiting**: Protect API endpoints from abuse with configurable rate limits
+- **🆕 Caching**: Improve performance with intelligent caching of frequently accessed data
+- **🆕 REST API**: Clean RESTful API endpoints for programmatic access
 
 ## Project Structure
 
@@ -740,6 +743,13 @@ For issues and questions:
 
 ## Changelog
 
+### Version 1.1.0 (Latest)
+- ✨ **NEW**: Rate limiting for API endpoints to prevent abuse
+- ✨ **NEW**: Caching system for improved performance
+- ✨ **NEW**: RESTful API endpoints for programmatic access
+- ✨ **NEW**: Comprehensive test suite for API functionality
+- 📚 **NEW**: Detailed documentation in `RATE_LIMITING_AND_CACHING.md`
+
 ### Version 1.0.0
 - Initial release
 - Multi-model LLM support
@@ -748,3 +758,31 @@ For issues and questions:
 - User authentication
 - JSON viewer
 - Admin interface
+
+## API Endpoints
+
+The application now includes RESTful API endpoints with rate limiting and caching:
+
+### Health Check
+```bash
+GET /api/health/
+# Rate limit: 200 requests/hour
+# Cached for 1 minute
+```
+
+### Conversation Statistics
+```bash
+GET /api/conversations/stats/
+# Rate limit: 50 requests/hour per user
+# Requires authentication
+# Cached for 5 minutes per user
+```
+
+### Delete Conversation
+```bash
+DELETE /api/conversations/<uuid>/
+# Rate limit: 50 requests/hour per user
+# Requires authentication
+```
+
+For complete API documentation, see [RATE_LIMITING_AND_CACHING.md](RATE_LIMITING_AND_CACHING.md).
diff --git a/__pycache__/env.cpython-311.pyc b/__pycache__/env.cpython-311.pyc
deleted file mode 100644
index 84d88ce..0000000
Binary files a/__pycache__/env.cpython-311.pyc and /dev/null differ
diff --git a/example_api_usage.py b/example_api_usage.py
new file mode 100755
index 0000000..e0a38d8
--- /dev/null
+++ b/example_api_usage.py
@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Example script demonstrating how to use the LLM Metadata Django App API
+with rate limiting and caching.
+
+This script shows how to:
+1. Check API health
+2. Get conversation statistics
+3. Handle rate limiting
+4. Utilize caching
+
+Prerequisites:
+- pip install requests
+- Django server running locally or on production
+"""
+
+import requests
+import time
+import json
+from typing import Dict, Optional
+
+
+class LLMMetadataClient:
+    """Client for interacting with the LLM Metadata API"""
+    
+    def __init__(self, base_url: str, auth_token: Optional[str] = None):
+        """
+        Initialize the API client
+        
+        Args:
+            base_url: Base URL of the API (e.g., 'http://localhost:8000')
+            auth_token: Optional authentication token for authenticated endpoints
+        """
+        self.base_url = base_url.rstrip('/')
+        self.session = requests.Session()
+        
+        if auth_token:
+            self.session.headers.update({
+                'Authorization': f'Bearer {auth_token}'
+            })
+    
+    def health_check(self) -> Dict:
+        """
+        Check API health status
+        
+        Returns:
+            Dictionary containing health status
+            
+        Rate limit: 200 requests/hour per IP
+        Cached: 1 minute
+        """
+        url = f'{self.base_url}/api/health/'
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+    
+    def get_conversation_stats(self) -> Dict:
+        """
+        Get conversation statistics for the authenticated user
+        
+        Returns:
+            Dictionary containing conversation statistics
+            
+        Rate limit: 50 requests/hour per user
+        Cached: 5 minutes per user
+        Requires: Authentication
+        """
+        url = f'{self.base_url}/api/conversations/stats/'
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+    
+    def delete_conversation(self, conversation_id: str) -> Dict:
+        """
+        Delete a conversation by UUID
+        
+        Args:
+            conversation_id: UUID of the conversation to delete
+            
+        Returns:
+            Dictionary containing deletion confirmation
+            
+        Rate limit: 50 requests/hour per user
+        Requires: Authentication
+        """
+        url = f'{self.base_url}/api/conversations/{conversation_id}/'
+        response = self.session.delete(url)
+        response.raise_for_status()
+        return response.json()
+
+
+def demonstrate_health_check(client: LLMMetadataClient):
+    """Demonstrate health check endpoint with caching"""
+    print("\n" + "="*60)
+    print("1. HEALTH CHECK DEMONSTRATION")
+    print("="*60)
+    
+    # First request - not cached
+    print("\n📡 Making first health check request...")
+    start_time = time.time()
+    health = client.health_check()
+    first_request_time = time.time() - start_time
+    
+    print(f"✓ Status: {health['status']}")
+    print(f"✓ Response time: {first_request_time*1000:.2f}ms")
+    print(f"✓ Total conversations: {health['database']['total_conversations']}")
+    
+    # Second request - cached (within 1 minute)
+    print("\n📡 Making second health check request (should be cached)...")
+    start_time = time.time()
+    health = client.health_check()
+    cached_request_time = time.time() - start_time
+    
+    print(f"✓ Status: {health['status']}")
+    print(f"✓ Response time: {cached_request_time*1000:.2f}ms")
+    
+    speedup = first_request_time / cached_request_time if cached_request_time > 0 else 0
+    print(f"\n⚡ Cache speedup: {speedup:.2f}x faster")
+
+
+def demonstrate_conversation_stats(client: LLMMetadataClient):
+    """Demonstrate conversation statistics with caching"""
+    print("\n" + "="*60)
+    print("2. CONVERSATION STATISTICS DEMONSTRATION")
+    print("="*60)
+    
+    # First request - not cached
+    print("\n📊 Fetching conversation statistics...")
+    start_time = time.time()
+    stats = client.get_conversation_stats()
+    first_request_time = time.time() - start_time
+    
+    print(f"✓ User: {stats['user']}")
+    print(f"✓ Total conversations: {stats['total_conversations']}")
+    print(f"✓ Recent conversations: {len(stats['recent_conversations'])}")
+    print(f"✓ Cached: {stats.get('cached', False)}")
+    print(f"✓ Response time: {first_request_time*1000:.2f}ms")
+    
+    # Second request - cached
+    print("\n📊 Fetching conversation statistics again (should be cached)...")
+    start_time = time.time()
+    stats = client.get_conversation_stats()
+    cached_request_time = time.time() - start_time
+    
+    print(f"✓ User: {stats['user']}")
+    print(f"✓ Cached: {stats.get('cached', False)}")
+    print(f"✓ Response time: {cached_request_time*1000:.2f}ms")
+    
+    speedup = first_request_time / cached_request_time if cached_request_time > 0 else 0
+    print(f"\n⚡ Cache speedup: {speedup:.2f}x faster")
+
+
+def demonstrate_rate_limiting(client: LLMMetadataClient):
+    """Demonstrate rate limiting by making multiple requests"""
+    print("\n" + "="*60)
+    print("3. RATE LIMITING DEMONSTRATION")
+    print("="*60)
+    
+    print("\n⏱️  Making rapid requests to test rate limiting...")
+    print("(This will stop when rate limit is reached)")
+    
+    for i in range(1, 11):
+        try:
+            health = client.health_check()
+            print(f"✓ Request {i}: Success (status: {health['status']})")
+            time.sleep(0.1)  # Small delay between requests
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 429:
+                print(f"\n⚠️  Rate limit reached at request {i}!")
+                print(f"   HTTP 429: Too Many Requests")
+                try:
+                    error_data = e.response.json()
+                    print(f"   Message: {error_data.get('detail', 'Rate limit exceeded')}")
+                except:
+                    pass
+                break
+            else:
+                raise
+
+
+def main():
+    """Main demonstration function"""
+    print("\n" + "="*60)
+    print("LLM METADATA API DEMONSTRATION")
+    print("Rate Limiting and Caching Features")
+    print("="*60)
+    
+    # Configuration
+    BASE_URL = "http://localhost:8000"  # Change to your server URL
+    AUTH_TOKEN = None  # Set this if you have an auth token
+    
+    print(f"\n📍 API Base URL: {BASE_URL}")
+    print(f"🔐 Authentication: {'Enabled' if AUTH_TOKEN else 'Disabled (using anonymous access)'}")
+    
+    # Create client
+    client = LLMMetadataClient(BASE_URL, AUTH_TOKEN)
+    
+    try:
+        # 1. Demonstrate health check with caching
+        demonstrate_health_check(client)
+        
+        # 2. Demonstrate conversation stats (requires authentication)
+        if AUTH_TOKEN:
+            demonstrate_conversation_stats(client)
+        else:
+            print("\n" + "="*60)
+            print("2. CONVERSATION STATISTICS DEMONSTRATION")
+            print("="*60)
+            print("\n⚠️  Skipped: Requires authentication")
+            print("   Set AUTH_TOKEN to enable this demonstration")
+        
+        # 3. Demonstrate rate limiting
+        demonstrate_rate_limiting(client)
+        
+        print("\n" + "="*60)
+        print("✅ DEMONSTRATION COMPLETE")
+        print("="*60)
+        print("\nKey Takeaways:")
+        print("1. ⚡ Caching significantly improves response times")
+        print("2. 🛡️  Rate limiting protects the API from abuse")
+        print("3. 🔒 Sensitive endpoints require authentication")
+        print("4. 📊 Statistics are cached per user for 5 minutes")
+        print("\nFor more information, see RATE_LIMITING_AND_CACHING.md")
+        
+    except requests.exceptions.ConnectionError:
+        print(f"\n❌ Error: Could not connect to {BASE_URL}")
+        print("   Make sure the Django server is running")
+    except requests.exceptions.HTTPError as e:
+        print(f"\n❌ HTTP Error: {e}")
+        if e.response.status_code == 401:
+            print("   Authentication required. Set AUTH_TOKEN in the script.")
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/main/__pycache__/__init__.cpython-311.pyc b/main/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 7b75cc4..0000000
Binary files a/main/__pycache__/__init__.cpython-311.pyc and /dev/null differ
diff --git a/main/__pycache__/settings.cpython-311.pyc b/main/__pycache__/settings.cpython-311.pyc
deleted file mode 100644
index 3cafee5..0000000
Binary files a/main/__pycache__/settings.cpython-311.pyc and /dev/null differ
diff --git a/main/__pycache__/urls.cpython-311.pyc b/main/__pycache__/urls.cpython-311.pyc
deleted file mode 100644
index 84dbc68..0000000
Binary files a/main/__pycache__/urls.cpython-311.pyc and /dev/null differ
diff --git a/main/__pycache__/wsgi.cpython-311.pyc b/main/__pycache__/wsgi.cpython-311.pyc
deleted file mode 100644
index 74cf93f..0000000
Binary files a/main/__pycache__/wsgi.cpython-311.pyc and /dev/null differ
diff --git a/main/settings.py b/main/settings.py
index 2581075..021c85a 100644
--- a/main/settings.py
+++ b/main/settings.py
@@ -50,6 +50,7 @@
     'allauth.socialaccount',
     'allauth.socialaccount.providers.google',
     'allauth.socialaccount.providers.github',
+    'rest_framework',
     'LLM_Metadata',
 ]
 
@@ -217,4 +218,56 @@
 
 
 MEDIA_URL = '/media/'
-MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
\ No newline at end of file
+MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
+
+
+# Cache configuration
+# Use Redis if available in production, otherwise fallback to local memory cache
+CACHES = {
+    'default': {
+        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
+        'LOCATION': 'unique-snowflake',
+        'TIMEOUT': 300,  # Default cache timeout in seconds (5 minutes)
+        'OPTIONS': {
+            'MAX_ENTRIES': 1000
+        }
+    }
+}
+
+# For production with Redis, use this configuration:
+# CACHES = {
+#     'default': {
+#         'BACKEND': 'django.core.cache.backends.redis.RedisCache',
+#         'LOCATION': os.environ.get('REDIS_URL', 'redis://127.0.0.1:6379/1'),
+#         'OPTIONS': {
+#             'CLIENT_CLASS': 'django.core.cache.backends.redis.RedisCache',
+#         },
+#         'TIMEOUT': 300,
+#     }
+# }
+
+# Rate limiting configuration
+# Rate limits are enforced using django-ratelimit
+RATELIMIT_ENABLE = True  # Can be set to False to disable rate limiting in development
+RATELIMIT_USE_CACHE = 'default'  # Use the default cache backend for rate limiting
+
+# REST Framework configuration
+REST_FRAMEWORK = {
+    'DEFAULT_RENDERER_CLASSES': [
+        'rest_framework.renderers.JSONRenderer',
+        'rest_framework.renderers.BrowsableAPIRenderer',
+    ],
+    'DEFAULT_PARSER_CLASSES': [
+        'rest_framework.parsers.JSONParser',
+        'rest_framework.parsers.FormParser',
+        'rest_framework.parsers.MultiPartParser',
+    ],
+    'DEFAULT_THROTTLE_CLASSES': [
+        'rest_framework.throttling.AnonRateThrottle',
+        'rest_framework.throttling.UserRateThrottle'
+    ],
+    'DEFAULT_THROTTLE_RATES': {
+        'anon': '100/hour',  # Anonymous users: 100 requests per hour
+        'user': '1000/hour',  # Authenticated users: 1000 requests per hour
+    }
+}
\ No newline at end of file
diff --git a/requirements_api.txt b/requirements_api.txt
new file mode 100644
index 0000000..97bb90c
--- /dev/null
+++ b/requirements_api.txt
@@ -0,0 +1,10 @@
+# API, Rate Limiting and Caching Dependencies
+Django==4.2.16
+djangorestframework==3.16.1
+django-ratelimit==4.1.0
+redis==7.0.1
+psycopg2==2.9.9
+dj-database-url==3.0.1
+django-allauth==65.13.0
+gunicorn==20.1.0
+whitenoise==6.8.2