Merge pull request #475 from MervinPraison/develop

v2.1.4

docker/Dockerfile

@@ -1,6 +1,6 @@
 FROM python:3.11-slim
 WORKDIR /app
 COPY . .
-RUN pip install flask praisonai==2.1.1 gunicorn markdown
+RUN pip install flask praisonai==2.1.4 gunicorn markdown
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

docker/Dockerfile.chat

@@ -13,7 +13,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
     praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.1.4" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -15,7 +15,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
     praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.1.4" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -13,7 +13,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
     praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.1.4" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

docs/api/praisonai/deploy.html

@@ -110,7 +110,7 @@ Loads environment variables from .env file or system and sets them.</p>
             file.write(&#34;FROM python:3.11-slim\n&#34;)
             file.write(&#34;WORKDIR /app\n&#34;)
             file.write(&#34;COPY . .\n&#34;)
-            file.write(&#34;RUN pip install flask praisonai==2.1.1 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.1.4 gunicorn markdown\n&#34;)
             file.write(&#34;EXPOSE 8080\n&#34;)
             file.write(&#39;CMD [&#34;gunicorn&#34;, &#34;-b&#34;, &#34;0.0.0.0:8080&#34;, &#34;api:app&#34;]\n&#39;)
             

docs/deploy/aws.mdx

@@ -0,0 +1,416 @@
+---
+title: "Deploying to AWS"
+sidebarTitle: "AWS"
+description: "Deploy PraisonAI agents to Amazon Web Services for scalable production environments"
+icon: "aws"
+---
+
+# Deploying PraisonAI Agents to AWS
+
+This guide provides step-by-step instructions for deploying PraisonAI agents to Amazon Web Services (AWS), offering multiple deployment options to suit different requirements.
+
+## Prerequisites
+
+- AWS account with appropriate permissions
+- AWS CLI installed and configured
+- Docker installed on your local machine (for container-based deployments)
+- Basic knowledge of AWS services and cloud deployment
+
+## Deployment Options
+
+There are several ways to deploy PraisonAI agents to AWS:
+
+1. **AWS Lambda with API Gateway** (for serverless deployments)
+2. **Amazon ECS/Fargate** (for containerized deployments)
+3. **Amazon EC2** (for traditional VM-based deployments)
+4. **AWS App Runner** (for simplified container deployments)
+
+## Option 1: Deploying to EC2 (Traditional VM)
+
+<Steps>
+    <Step title="Launch an EC2 Instance">
+        1. Go to the AWS Management Console
+        2. Navigate to EC2 and click "Launch Instance"
+        3. Choose Amazon Linux 2 or Ubuntu Server
+        4. Select an instance type (t2.micro for testing, t2.medium or larger for production)
+        5. Configure security groups to allow HTTP/HTTPS traffic
+        6. Launch the instance and connect to it via SSH
+    </Step>
+
+    <Step title="Set Up the Environment">
+        ```bash
+        # Update system packages
+        sudo apt update && sudo apt upgrade -y
+        
+        # Install Python and pip
+        sudo apt install -y python3 python3-pip
+        
+        # Install required packages
+        pip3 install "praisonaiagents[api]>=0.0.79"
+        ```
+    </Step>
+
+    <Step title="Create the API Application">
+        Create a file named `api.py`:
+        
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+    </Step>
+
+    <Step title="Set Up a Systemd Service">
+        Create a systemd service file to run your application as a background service:
+        
+        ```bash
+        sudo nano /etc/systemd/system/praisonai-agent.service
+        ```
+        
+        Add the following content:
+        
+        ```ini
+        [Unit]
+        Description=PraisonAI Agent API Service
+        After=network.target
+
+        [Service]
+        User=ubuntu
+        WorkingDirectory=/home/ubuntu
+        Environment="OPENAI_API_KEY=your_api_key"
+        ExecStart=/usr/bin/python3 /home/ubuntu/api.py
+        Restart=always
+
+        [Install]
+        WantedBy=multi-user.target
+        ```
+        
+        Enable and start the service:
+        
+        ```bash
+        sudo systemctl daemon-reload
+        sudo systemctl enable praisonai-agent
+        sudo systemctl start praisonai-agent
+        ```
+    </Step>
+
+    <Step title="Set Up Nginx as a Reverse Proxy">
+        ```bash
+        # Install Nginx
+        sudo apt install -y nginx
+        
+        # Create a configuration file
+        sudo nano /etc/nginx/sites-available/praisonai-agent
+        ```
+        
+        Add the following configuration:
+        
+        ```nginx
+        server {
+            listen 80;
+            server_name your_domain.com;
+
+            location / {
+                proxy_pass http://localhost:8080;
+                proxy_set_header Host $host;
+                proxy_set_header X-Real-IP $remote_addr;
+                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+                proxy_set_header X-Forwarded-Proto $scheme;
+            }
+        }
+        ```
+        
+        Enable the site and restart Nginx:
+        
+        ```bash
+        sudo ln -s /etc/nginx/sites-available/praisonai-agent /etc/nginx/sites-enabled/
+        sudo nginx -t
+        sudo systemctl restart nginx
+        ```
+    </Step>
+</Steps>
+
+## Option 2: Deploying with Docker and ECS/Fargate
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Run the application
+        CMD ["python", "api.py"]
+        ```
+        
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+        
+        Create your `api.py` file:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+    </Step>
+
+    <Step title="Build and Push the Docker Image to ECR">
+        ```bash
+        # Create an ECR repository
+        aws ecr create-repository --repository-name praisonai-agent
+        
+        # Get the login command
+        aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
+        
+        # Build the Docker image
+        docker build -t praisonai-agent .
+        
+        # Tag the image
+        docker tag praisonai-agent:latest YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest
+        
+        # Push the image to ECR
+        docker push YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest
+        ```
+    </Step>
+
+    <Step title="Create an ECS Cluster and Task Definition">
+        ```bash
+        # Create an ECS cluster
+        aws ecs create-cluster --cluster-name praisonai-cluster
+        
+        # Create a task definition (JSON file)
+        cat > task-definition.json << EOF
+        {
+          "family": "praisonai-agent",
+          "networkMode": "awsvpc",
+          "executionRoleArn": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/ecsTaskExecutionRole",
+          "containerDefinitions": [
+            {
+              "name": "praisonai-agent",
+              "image": "YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest",
+              "essential": true,
+              "portMappings": [
+                {
+                  "containerPort": 8080,
+                  "hostPort": 8080,
+                  "protocol": "tcp"
+                }
+              ],
+              "environment": [
+                {
+                  "name": "OPENAI_API_KEY",
+                  "value": "your_api_key"
+                }
+              ],
+              "logConfiguration": {
+                "logDriver": "awslogs",
+                "options": {
+                  "awslogs-group": "/ecs/praisonai-agent",
+                  "awslogs-region": "us-east-1",
+                  "awslogs-stream-prefix": "ecs"
+                }
+              }
+            }
+          ],
+          "requiresCompatibilities": [
+            "FARGATE"
+          ],
+          "cpu": "256",
+          "memory": "512"
+        }
+        EOF
+        
+        # Register the task definition
+        aws ecs register-task-definition --cli-input-json file://task-definition.json
+        ```
+    </Step>
+
+    <Step title="Create a Fargate Service">
+        ```bash
+        # Create a service
+        aws ecs create-service \
+          --cluster praisonai-cluster \
+          --service-name praisonai-service \
+          --task-definition praisonai-agent:1 \
+          --desired-count 1 \
+          --launch-type FARGATE \
+          --network-configuration "awsvpcConfiguration={subnets=[subnet-12345678],securityGroups=[sg-12345678],assignPublicIp=ENABLED}" \
+          --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef,containerName=praisonai-agent,containerPort=8080"
+        ```
+        
+        Note: You'll need to create an Application Load Balancer and target group before running this command.
+    </Step>
+</Steps>
+
+## Multi-Agent Deployment
+
+For deploying multiple agents, you can use a single service with different endpoints:
+
+```python
+# multi-agent-api.py
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=8080, host="0.0.0.0")
+stock_agent.launch(path="/stock", port=8080, host="0.0.0.0")
+travel_agent.launch(path="/travel", port=8080, host="0.0.0.0")
+```
+
+## Option 3: Serverless Deployment with AWS Lambda
+
+For lightweight agents that don't require long-running processes, you can use AWS Lambda with API Gateway:
+
+```python
+# lambda_function.py
+from praisonaiagents import Agent
+import json
+
+# Initialize the agent outside the handler for better cold start performance
+agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+
+def lambda_handler(event, context):
+    try:
+        # Extract the message from the event
+        body = json.loads(event.get('body', '{}'))
+        message = body.get('message', '')
+        
+        # Process the message with the agent
+        response = agent.process(message)
+        
+        # Return the response
+        return {
+            'statusCode': 200,
+            'headers': {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+            },
+            'body': json.dumps({
+                'response': response
+            })
+        }
+    except Exception as e:
+        return {
+            'statusCode': 500,
+            'headers': {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+            },
+            'body': json.dumps({
+                'error': str(e)
+            })
+        }
+```
+
+## Scaling and Performance
+
+### Auto Scaling
+
+For EC2 deployments, set up an Auto Scaling group:
+
+```bash
+# Create a launch template
+aws ec2 create-launch-template \
+  --launch-template-name praisonai-template \
+  --version-description "Initial version" \
+  --launch-template-data '{"ImageId":"ami-12345678","InstanceType":"t2.medium","UserData":"#!/bin/bash\ncd /home/ubuntu\npython3 api.py &"}'  
+
+# Create an Auto Scaling group
+aws autoscaling create-auto-scaling-group \
+  --auto-scaling-group-name praisonai-asg \
+  --launch-template "LaunchTemplateName=praisonai-template,Version=1" \
+  --min-size 1 \
+  --max-size 5 \
+  --desired-capacity 2 \
+  --vpc-zone-identifier "subnet-12345678,subnet-87654321" \
+  --target-group-arns "arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef"
+```
+
+### Load Balancing
+
+Set up an Application Load Balancer to distribute traffic:
+
+```bash
+# Create a load balancer
+aws elbv2 create-load-balancer \
+  --name praisonai-alb \
+  --subnets subnet-12345678 subnet-87654321 \
+  --security-groups sg-12345678
+
+# Create a target group
+aws elbv2 create-target-group \
+  --name praisonai-tg \
+  --protocol HTTP \
+  --port 8080 \
+  --vpc-id vpc-12345678 \
+  --target-type instance
+
+# Create a listener
+aws elbv2 create-listener \
+  --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:loadbalancer/app/praisonai-alb/1234567890abcdef \
+  --protocol HTTP \
+  --port 80 \
+  --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef
+```
+
+## Security Best Practices
+
+1. **Secret Management**: Use AWS Secrets Manager for API keys
+   ```bash
+   # Store a secret
+   aws secretsmanager create-secret \
+     --name OPENAI_API_KEY \
+     --secret-string "your_api_key"
+   ```
+
+2. **IAM Roles**: Use the principle of least privilege
+3. **VPC**: Deploy in a private subnet with controlled access
+4. **WAF**: Set up AWS WAF to protect against common web exploits
+5. **API Gateway**: Implement request validation and throttling
+
+## Monitoring and Logging
+
+1. **CloudWatch**: Set up dashboards and alarms
+   ```bash
+   # Create a CloudWatch alarm for high CPU utilization
+   aws cloudwatch put-metric-alarm \
+     --alarm-name praisonai-high-cpu \
+     --alarm-description "Alarm when CPU exceeds 80%" \
+     --metric-name CPUUtilization \
+     --namespace AWS/EC2 \
+     --statistic Average \
+     --period 300 \
+     --threshold 80 \
+     --comparison-operator GreaterThanThreshold \
+     --dimensions Name=AutoScalingGroupName,Value=praisonai-asg \
+     --evaluation-periods 2 \
+     --alarm-actions arn:aws:sns:us-east-1:YOUR_AWS_ACCOUNT_ID:praisonai-alerts
+   ```
+
+2. **X-Ray**: Enable tracing for detailed request analysis
+3. **CloudTrail**: Monitor API calls for security analysis
+4. **Log Insights**: Query and analyze logs with CloudWatch Log Insights

docs/deploy/deploy.mdx

@@ -0,0 +1,223 @@
+---
+title: "Deploying PraisonAI Agents as APIs"
+sidebarTitle: "API Deployment"
+description: "Learn how to deploy PraisonAI agents as RESTful APIs for production environments"
+icon: "server"
+---
+
+PraisonAI agents can be easily deployed as RESTful APIs, allowing you to integrate them into various applications and services. This guide covers how to deploy both single and multiple agents as APIs.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[api]"
+        ```
+    </Step>
+    <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY="your_api_key"
+        ```
+    </Step>
+    <Step title="Deploy a Simple Agent API">
+        Create a file named `simple-api.py` with the following code:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=3030)
+        ```
+    </Step>
+    <Step title="Run the API Server">
+        ```bash
+        python simple-api.py
+        ```
+        
+        Your API will be available at `http://localhost:3030/ask`
+    </Step>
+</Steps>
+
+## Making API Requests
+
+Once your agent is deployed, you can make POST requests to interact with it:
+
+```bash
+curl -X POST http://localhost:3030/ask \
+  -H "Content-Type: application/json" \
+  -d '{"message": "What is artificial intelligence?"}'
+```
+
+The response will be in JSON format:
+
+```json
+{
+  "response": "Artificial intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think and learn like humans. It encompasses various technologies including machine learning, natural language processing, computer vision, and robotics. AI systems can perform tasks that typically require human intelligence such as understanding natural language, recognizing patterns, solving problems, and making decisions."
+}
+```
+
+## Multi-Agent API Deployment
+
+You can deploy multiple agents on the same server, each with its own endpoint:
+
+```python
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 
+```
+
+With this setup, you can access:
+- Weather agent at `http://localhost:3030/weather`
+- Stock agent at `http://localhost:3030/stock`
+- Travel agent at `http://localhost:3030/travel`
+
+## Production Deployment Options
+
+For production environments, consider the following deployment options:
+
+### Docker Deployment
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        COPY . .
+
+        EXPOSE 3030
+
+        CMD ["python", "api.py"]
+        ```
+    </Step>
+    <Step title="Create requirements.txt">
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+    </Step>
+    <Step title="Build and Run Docker Container">
+        ```bash
+        docker build -t praisonai-api .
+        docker run -p 3030:3030 -e OPENAI_API_KEY=your_api_key praisonai-api
+        ```
+    </Step>
+</Steps>
+
+### Cloud Deployment
+
+#### Deploying to AWS
+
+<Steps>
+    <Step title="Create an EC2 Instance">
+        Launch an EC2 instance with Ubuntu or Amazon Linux.
+    </Step>
+    <Step title="Install Dependencies">
+        ```bash
+        sudo apt update
+        sudo apt install -y python3-pip
+        pip install "praisonaiagents[api]"
+        ```
+    </Step>
+    <Step title="Configure Security Group">
+        Make sure to open port 3030 in your security group settings.
+    </Step>
+    <Step title="Run with Systemd">
+        Create a systemd service file for automatic startup and management.
+    </Step>
+</Steps>
+
+#### Deploying to Google Cloud Run
+
+<Steps>
+    <Step title="Build Docker Image">
+        ```bash
+        docker build -t gcr.io/your-project/praisonai-api .
+        ```
+    </Step>
+    <Step title="Push to Container Registry">
+        ```bash
+        docker push gcr.io/your-project/praisonai-api
+        ```
+    </Step>
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy praisonai-api \
+          --image gcr.io/your-project/praisonai-api \
+          --platform managed \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+    </Step>
+</Steps>
+
+## API Configuration Options
+
+When launching your agent as an API, you can customize various parameters:
+
+```python
+agent.launch(
+    path="/custom-endpoint",  # API endpoint path
+    port=8080,                # Port number
+    host="0.0.0.0",           # Host address (0.0.0.0 for external access)
+    debug=True,               # Enable debug mode
+    cors_origins=["*"],       # CORS configuration
+    api_key="your-api-key"    # Optional API key for authentication
+)
+```
+
+## Securing Your API
+
+For production deployments, consider implementing:
+
+1. **API Key Authentication**: Require API keys for all requests
+2. **Rate Limiting**: Limit the number of requests per client
+3. **HTTPS**: Use SSL/TLS certificates for encrypted communication
+4. **Input Validation**: Validate all input data before processing
+
+## Monitoring and Scaling
+
+For production environments, consider:
+
+1. **Load Balancing**: Distribute traffic across multiple instances
+2. **Auto-Scaling**: Automatically adjust resources based on demand
+3. **Logging**: Implement comprehensive logging for debugging
+4. **Monitoring**: Set up alerts for errors and performance issues
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="RESTful API" icon="server">
+    Deploy your agents as standard RESTful APIs for easy integration.
+  </Card>
+  <Card title="Multi-Agent Support" icon="users">
+    Deploy multiple agents with different endpoints on the same server.
+  </Card>
+  <Card title="Customizable" icon="gear">
+    Configure ports, paths, CORS settings, and more.
+  </Card>
+  <Card title="Production-Ready" icon="rocket">
+    Easily deploy to Docker, AWS, Google Cloud, or other cloud platforms.
+  </Card>
+</CardGroup>

docs/deploy/googlecloud.mdx

@@ -0,0 +1,248 @@
+---
+title: "Deploying to Google Cloud"
+sidebarTitle: "Google Cloud"
+description: "Deploy PraisonAI agents to Google Cloud Platform for scalable production environments"
+icon: "google"
+---
+
+# Deploying PraisonAI Agents to Google Cloud
+
+This guide provides step-by-step instructions for deploying PraisonAI agents to Google Cloud Platform using Cloud Run, which offers a serverless environment for containerized applications.
+
+## Prerequisites
+
+- Google Cloud account with billing enabled
+- Google Cloud SDK installed and configured
+- Docker installed on your local machine
+- Basic knowledge of containerization and cloud deployment
+
+## Deployment Options
+
+There are several ways to deploy PraisonAI agents to Google Cloud:
+
+1. **Google Cloud Run** (recommended for most use cases)
+2. **Google Compute Engine** (for custom VM requirements)
+3. **Google Kubernetes Engine** (for complex, scalable deployments)
+
+This guide focuses on Cloud Run as it's the simplest and most cost-effective option for most deployments.
+
+## Deploying to Google Cloud Run
+
+<Steps>
+    <Step title="Prepare Your Application">
+        Create a simple API file named `api.py`:
+
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+
+        Note: Cloud Run expects your application to listen on the port defined by the `PORT` environment variable, which defaults to 8080.
+    </Step>
+
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Set environment variables
+        ENV PORT=8080
+
+        # Run the application
+        CMD exec python api.py
+        ```
+
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+    </Step>
+
+    <Step title="Build and Push the Docker Image">
+        ```bash
+        # Build the Docker image
+        docker build -t gcr.io/YOUR_PROJECT_ID/praisonai-agent .
+
+        # Configure Docker to use Google Cloud credentials
+        gcloud auth configure-docker
+
+        # Push the image to Google Container Registry
+        docker push gcr.io/YOUR_PROJECT_ID/praisonai-agent
+        ```
+    </Step>
+
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy praisonai-agent \
+          --image gcr.io/YOUR_PROJECT_ID/praisonai-agent \
+          --platform managed \
+          --region us-central1 \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+
+        Note: For production deployments, it's recommended to use Secret Manager for API keys instead of environment variables.
+    </Step>
+</Steps>
+
+## Multi-Agent Deployment
+
+For deploying multiple agents, you can use a single Cloud Run service with different endpoints:
+
+```python
+# multi-agent-api.py
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=8080, host="0.0.0.0")
+stock_agent.launch(path="/stock", port=8080, host="0.0.0.0")
+travel_agent.launch(path="/travel", port=8080, host="0.0.0.0")
+```
+
+## Scaling and Performance
+
+Google Cloud Run automatically scales based on traffic, from zero to many instances. You can configure:
+
+- **Minimum instances**: Keep a certain number of instances warm to avoid cold starts
+- **Maximum instances**: Limit the number of instances to control costs
+- **Memory allocation**: Allocate more memory for complex agents
+- **CPU allocation**: Allocate dedicated CPUs for compute-intensive workloads
+
+```bash
+gcloud run services update praisonai-agent \
+  --min-instances=1 \
+  --max-instances=10 \
+  --memory=2Gi \
+  --cpu=1
+```
+
+## Continuous Deployment
+
+Set up continuous deployment with Cloud Build:
+
+```yaml
+# cloudbuild.yaml
+steps:
+  # Build the container image
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['build', '-t', 'gcr.io/$PROJECT_ID/praisonai-agent', '.']
+  # Push the container image to Container Registry
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['push', 'gcr.io/$PROJECT_ID/praisonai-agent']
+  # Deploy container image to Cloud Run
+  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
+    entrypoint: gcloud
+    args:
+    - 'run'
+    - 'deploy'
+    - 'praisonai-agent'
+    - '--image'
+    - 'gcr.io/$PROJECT_ID/praisonai-agent'
+    - '--region'
+    - 'us-central1'
+    - '--platform'
+    - 'managed'
+    - '--allow-unauthenticated'
+substitutions:
+  _REGION: us-central1
+images:
+  - 'gcr.io/$PROJECT_ID/praisonai-agent'
+```
+
+## Monitoring and Logging
+
+Google Cloud provides comprehensive monitoring and logging capabilities:
+
+- **Cloud Monitoring**: Set up dashboards and alerts for your deployed agents
+- **Cloud Logging**: View and analyze logs from your applications
+- **Error Reporting**: Automatically detect and group errors
+
+Access logs through the Google Cloud Console or using the gcloud command:
+
+```bash
+gcloud logging read "resource.type=cloud_run_revision AND resource.labels.service_name=praisonai-agent" --limit=10
+```
+
+## Cost Optimization
+
+Cloud Run charges based on the resources your service uses only when it's processing requests. To optimize costs:
+
+1. Set appropriate memory and CPU allocations
+2. Configure minimum instances based on traffic patterns
+3. Use regional deployments closest to your users
+4. Implement caching for frequent requests
+
+## Security Best Practices
+
+1. **Secret Management**: Store API keys and credentials in Secret Manager
+   ```bash
+   # Create a secret
+   echo -n "your_api_key" | gcloud secrets create openai-api-key --data-file=-
+   
+   # Grant access to the Cloud Run service
+   gcloud secrets add-iam-policy-binding openai-api-key \
+     --member=serviceAccount:YOUR_SERVICE_ACCOUNT \
+     --role=roles/secretmanager.secretAccessor
+   
+   # Reference in deployment
+   gcloud run deploy praisonai-agent \
+     --image gcr.io/YOUR_PROJECT_ID/praisonai-agent \
+     --set-secrets=OPENAI_API_KEY=openai-api-key:latest
+   ```
+
+2. **Service Identity**: Use dedicated service accounts with minimal permissions
+3. **Network Security**: Configure VPC Service Controls for sensitive deployments
+4. **API Authentication**: Implement authentication for your API endpoints
+
+## All in One 
+
+```bash
+gcloud init
+gcloud services enable run.googleapis.com
+gcloud services enable containerregistry.googleapis.com
+gcloud services enable cloudbuild.googleapis.com
+
+export OPENAI_MODEL_NAME="gpt-4o"
+export OPENAI_API_KEY="Enter your API key"
+export OPENAI_API_BASE="https://api.openai.com/v1"
+
+yes | gcloud auth configure-docker us-central1-docker.pkg.dev 
+gcloud artifacts repositories create praisonai-repository --repository-format=docker --location=us-central1
+
+PROJECT_ID=$(gcloud config get-value project)
+TAG="latest"
+docker build --platform linux/amd64 -t gcr.io/${PROJECT_ID}/praisonai-app:${TAG} .
+docker tag gcr.io/${PROJECT_ID}/praisonai-app:${TAG} us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG}
+docker push us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG}
+
+gcloud run deploy praisonai-service \
+    --image us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG} \
+    --platform managed \
+    --region us-central1 \
+    --allow-unauthenticated \
+    --set-env-vars OPENAI_MODEL_NAME=${OPENAI_MODEL_NAME},OPENAI_API_KEY=${OPENAI_API_KEY},OPENAI_API_BASE=${OPENAI_API_BASE}
+```

docs/developers/local-development.mdx

@@ -27,7 +27,7 @@ WORKDIR /app
 
 COPY . .
 
-RUN pip install flask praisonai==2.0.18 watchdog
+RUN pip install flask praisonai==2.1.4 watchdog
 
 EXPOSE 5555
 

docs/mint.json

@@ -55,14 +55,6 @@
     }
   ],
   "tabs": [
-    {
-        "name": "Documentation",
-        "url": "/index"
-    },
-    {
-        "name": "Examples",
-        "url": "/examples"
-    },
     {
         "name": "Agents",
         "url": "/agents"
@@ -79,6 +71,14 @@
         "name": "MCP",
         "url": "/mcp"
     },
+    {
+        "name": "Deploy",
+        "url": "/deploy"
+    },
+    {
+      "name": "Examples",
+      "url": "/examples"
+    },
     {
         "name": "JS",
         "url": "/js"
@@ -372,6 +372,14 @@
         "ui/code"
       ]
     },
+    {
+      "group": "Deploy",
+      "pages": [
+        "deploy/deploy",
+        "deploy/aws",
+        "deploy/googlecloud"
+      ]
+    },
     {
       "group": "Monitoring",
       "pages": ["monitoring/agentops"]
@@ -385,8 +393,7 @@
         "developers/wrapper-tools",
         "developers/googlecolab",
         "developers/googlecolab-tools",
-        "developers/local-development",
-        "deploy"
+        "developers/local-development"
       ]
     },
     {

docs/ui/chat.mdx

@@ -155,7 +155,7 @@ To facilitate local development with live reload, you can use Docker. Follow the
 
     COPY . .
 
-    RUN pip install flask praisonai==2.0.18 watchdog
+    RUN pip install flask praisonai==2.1.4 watchdog
 
     EXPOSE 5555
 

docs/ui/code.mdx

@@ -208,7 +208,7 @@ To facilitate local development with live reload, you can use Docker. Follow the
 
     COPY . .
 
-    RUN pip install flask praisonai==2.0.18 watchdog
+    RUN pip install flask praisonai==2.1.4 watchdog
 
     EXPOSE 5555
 

examples/api/multi-agent-api.py

@@ -0,0 +1,20 @@
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 

examples/api/simple-api-mcp.py

@@ -0,0 +1,8 @@
+from praisonaiagents import Agent, MCP
+
+search_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="openai/gpt-4o-mini",
+    tools=MCP("http://localhost:8080/sse")
+)
+search_agent.launch(path="/weather", port=3030)

examples/api/simple-api.py

@@ -0,0 +1,4 @@
+from praisonaiagents import Agent
+
+agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+agent.launch(path="/ask", port=3030)

praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.1.1 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.1.4 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.1.1"
+version = "2.1.4"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.71",
+    "praisonaiagents>=0.0.79",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -21,49 +21,53 @@ dependencies = [
 
 [project.optional-dependencies]
 ui = [
-    "chainlit==2.0.3",
+    "chainlit==2.5.5",
     "sqlalchemy>=2.0.36",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
     "pydantic<=2.10.1"
 ]
 gradio = ["gradio>=4.26.0"]
-api = ["flask>=3.0.0"]
+api = [
+    "flask>=3.0.0",
+    "fastapi>=0.115.0",
+    "uvicorn>=0.34.0"
+]
 agentops = ["agentops>=0.3.12"]
-google = ["langchain-google-genai>=1.0.4"]
-openai = ["langchain-openai>=0.1.7"]
-anthropic = ["langchain-anthropic>=0.1.13"]
-cohere = ["langchain-cohere>=0.1.4"]
+google = ["langchain-google-genai>=2.1.0"]
+openai = ["langchain-openai>=0.2.1,<0.3.0"]
+anthropic = ["langchain-anthropic>=0.3.0"]
+cohere = ["langchain-cohere>=0.3.0,<0.4.0"]
 chat = [
-    "chainlit==2.0.3",
+    "chainlit==2.5.5",
     "litellm>=1.41.8",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
     "tavily-python==0.5.0",
-    "crawl4ai==0.3.4",
+    "crawl4ai>=0.6.0",
     "sqlalchemy>=2.0.36",
     "playwright>=1.47.0",
     "rich",
     "pydantic<=2.10.1"
 ]
 code = [
-    "chainlit==2.0.3",
+    "chainlit==2.5.5",
     "litellm>=1.41.8",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
     "tavily-python==0.5.0",
-    "crawl4ai==0.3.4",
+    "crawl4ai>=0.6.0",
     "sqlalchemy>=2.0.36",
     "playwright>=1.47.0",
     "pydantic<=2.10.1"
 ]
 realtime = [
-    "chainlit==2.0.3",
+    "chainlit==2.5.5",
     "litellm>=1.41.8",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
     "tavily-python==0.5.0",
-    "crawl4ai==0.3.4",
+    "crawl4ai>=0.6.0",
     "websockets>=12.0",
     "plotly>=5.24.0",
     "yfinance>=0.2.44",
@@ -80,13 +84,13 @@ call = [
     "rich",
     "openai>=1.54.0",
 ]
-crewai = ["crewai>=0.32.0", "praisonai-tools>=0.0.7"]
-autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.7", "crewai"]
+crewai = ["crewai>=0.32.0", "praisonai-tools>=0.0.15"]
+autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.1.1"
-description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
+version = "2.1.4"
+description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
 readme = "README.md"
@@ -103,27 +107,27 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.71"
+praisonaiagents = ">=0.0.79"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"
 mcp = "==1.6.0"
 pyautogen = {version = ">=0.2.19", optional = true}
 crewai = {version = ">=0.32.0", optional = true}
-praisonai-tools = {version = ">=0.0.7", optional = true}
-chainlit = {version = "==2.0.3", optional = true}
+praisonai-tools = {version = ">=0.0.15", optional = true}
+chainlit = {version = "==2.5.5", optional = true}
 gradio = {version = ">=4.26.0", optional = true}
 flask = {version = ">=3.0.0", optional = true}
 agentops = {version = ">=0.3.12", optional = true}
-langchain-google-genai = {version = ">=1.0.4", optional = true}
-langchain-anthropic = {version = ">=0.1.13", optional = true}
-langchain-openai = {version = ">=0.1.7", optional = true}
-langchain-cohere = {version = ">=0.1.4", optional = true}
+langchain-google-genai = {version = ">=2.1.0", optional = true}
+langchain-anthropic = {version = ">=0.3.0", optional = true}
+langchain-openai = {version = ">=0.2.1,<0.3.0", optional = true}
+langchain-cohere = {version = ">=0.3.0,<0.4.0", optional = true}
 litellm = {version = ">=1.41.8", optional = true}
 aiosqlite= {version = ">=0.20.0", optional = true}
 greenlet = {version = ">=3.0.3", optional = true}
 tavily-python = {version = "==0.5.0", optional=true}
-crawl4ai = {version = "==0.3.4", optional = true}
+crawl4ai = {version = ">=0.6.0", optional = true}
 websockets = {version = ">=12.0", optional = true}
 plotly = {version = ">=5.24.0", optional = true}
 yfinance = {version = ">=0.2.44", optional = true}
@@ -175,14 +179,14 @@ mkdocstrings-python = "*"
 pdoc3 = "*"
 xmlrunner = "*"
 unittest2 = "*"
-chainlit = "==2.0.3"
+chainlit = "==2.5.5"
 gradio = ">=4.26.0"
 flask = ">=3.0.0"
 agentops = ">=0.3.12"
-langchain-google-genai = ">=1.0.4"
-langchain-anthropic = ">=0.1.13"
-langchain-openai = ">=0.1.7"
-langchain-cohere = ">=0.1.4"
+langchain-google-genai = ">=2.1.0"
+langchain-anthropic = ">=0.3.0"
+langchain-openai = ">=0.2.1,<0.3.0"
+langchain-cohere = ">=0.3.0,<0.4.0"
 litellm = ">=1.41.8"
 aiosqlite = ">=0.20.0"
 greenlet = ">=3.0.3"

src/praisonai-agents/multi-agent-api.py

@@ -1,29 +1,20 @@
 from praisonaiagents import Agent
 
-# Create a weather agent
 weather_agent = Agent(
     instructions="""You are a weather agent that can provide weather information for a given city.""",
     llm="gpt-4o-mini"
 )
 
-# Create a stock market agent 
 stock_agent = Agent(
     instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
     llm="gpt-4o-mini"
 )
 
-# Create a travel agent
 travel_agent = Agent(
     instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
     llm="gpt-4o-mini"
 )
 
-# Register the first two agents with blocking=False so they don't block execution
-weather_agent.launch(path="/weather", port=3030, blocking=False)
-stock_agent.launch(path="/stock", port=3030, blocking=False)
-
-# Register the last agent with blocking=True to keep the server running
-# This must be the last launch() call
-travel_agent.launch(path="/travel", port=3030, blocking=True)
-
-# The script will block at the last launch() call until the user presses Ctrl+C
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -22,16 +22,16 @@ import inspect
 import uuid
 from dataclasses import dataclass
 
+# Global variables for API server
+_server_started = False
+_registered_agents = {}
+_shared_app = None
+
 # Don't import FastAPI dependencies here - use lazy loading instead
 
 if TYPE_CHECKING:
     from ..task.task import Task
 
-# Shared variables for API server
-_shared_app = None
-_server_started = False
-_registered_agents = {}
-
 @dataclass
 class ChatCompletionMessage:
     content: str
@@ -1408,7 +1408,7 @@ Your Goal: {self.goal}
             logging.error(f"Error in execute_tool_async: {str(e)}", exc_info=True)
             return {"error": f"Error in execute_tool_async: {str(e)}"}
 
-    def launch(self, path: str = '/', port: int = 8000, host: str = '0.0.0.0', autostart: bool = True, debug: bool = False, blocking: bool = True):
+    def launch(self, path: str = '/', port: int = 8000, host: str = '0.0.0.0', debug: bool = False):
         """
         Launch the agent as an HTTP API endpoint.
         
@@ -1416,9 +1416,7 @@ Your Goal: {self.goal}
             path: API endpoint path (default: '/')
             port: Server port (default: 8000)
             host: Server host (default: '0.0.0.0')
-            autostart: Whether to start the server automatically (default: True)
             debug: Enable debug mode for uvicorn (default: False)
-            blocking: If True, blocks the main thread to keep the server running (default: True)
             
         Returns:
             None
@@ -1431,6 +1429,8 @@ Your Goal: {self.goal}
             from fastapi import FastAPI, HTTPException, Request
             from fastapi.responses import JSONResponse
             from pydantic import BaseModel
+            import threading
+            import time
             
             # Define the request model here since we need pydantic
             class AgentQuery(BaseModel):
@@ -1458,6 +1458,11 @@ Your Goal: {self.goal}
             @_shared_app.get("/")
             async def root():
                 return {"message": "Welcome to PraisonAI Agents API. See /docs for usage."}
+            
+            # Add healthcheck endpoint
+            @_shared_app.get("/health")
+            async def healthcheck():
+                return {"status": "ok", "agents": list(_registered_agents.keys())}
         
         # Normalize path to ensure it starts with /
         if not path.startswith('/'):
@@ -1516,47 +1521,68 @@ Your Goal: {self.goal}
         
         print(f"🚀 Agent '{self.name}' available at http://{host}:{port}{path}")
         
-        # Start the server if this is the first launch call and autostart is True
-        if autostart and not _server_started:
+        # Start the server if it's not already running
+        if not _server_started:
             _server_started = True
             
-            # Add healthcheck endpoint
-            @_shared_app.get("/health")
-            async def healthcheck():
-                return {"status": "ok", "agents": list(_registered_agents.keys())}
-            
-            # Start the server in a separate thread to not block execution
-            import threading
+            # Start the server in a separate thread
             def run_server():
                 try:
+                    print(f"✅ FastAPI server started at http://{host}:{port}")
+                    print(f"📚 API documentation available at http://{host}:{port}/docs")
+                    print(f"🔌 Available endpoints: {', '.join(list(_registered_agents.keys()))}")
                     uvicorn.run(_shared_app, host=host, port=port, log_level="debug" if debug else "info")
                 except Exception as e:
                     logging.error(f"Error starting server: {str(e)}", exc_info=True)
                     print(f"❌ Error starting server: {str(e)}")
             
+            # Run server in a background thread
             server_thread = threading.Thread(target=run_server, daemon=True)
             server_thread.start()
             
-            # Give the server a moment to start up
-            import time
+            # Wait for a moment to allow the server to start and register endpoints
             time.sleep(0.5)
+        else:
+            # If server is already running, wait a moment to make sure the endpoint is registered
+            time.sleep(0.1)
+            print(f"🔌 Available endpoints: {', '.join(list(_registered_agents.keys()))}")
+        
+        # Get the stack frame to check if this is the last launch() call in the script
+        import inspect
+        stack = inspect.stack()
+        
+        # If this is called from a Python script (not interactive), try to detect if it's the last launch call
+        if len(stack) > 1 and stack[1].filename.endswith('.py'):
+            caller_frame = stack[1]
+            caller_line = caller_frame.lineno
             
-            print(f"✅ FastAPI server started at http://{host}:{port}")
-            print(f"📚 API documentation available at http://{host}:{port}/docs")
-            
-            # If blocking is True, keep the main thread alive
-            if blocking:
-                print("\nServer is running in blocking mode. Press Ctrl+C to stop...")
+            try:
+                # Read the file to check if there are more launch calls after this one
+                with open(caller_frame.filename, 'r') as f:
+                    lines = f.readlines()
+                
+                # Check if there are more launch() calls after the current line
+                has_more_launches = False
+                for line in lines[caller_line:]:
+                    if '.launch(' in line and not line.strip().startswith('#'):
+                        has_more_launches = True
+                        break
+                
+                # If this is the last launch call, block the main thread
+                if not has_more_launches:
+                    try:
+                        print("\nAll agents registered. Press Ctrl+C to stop the server.")
+                        while True:
+                            time.sleep(1)
+                    except KeyboardInterrupt:
+                        print("\nServer stopped")
+            except Exception as e:
+                # If something goes wrong with detection, block anyway to be safe
+                logging.error(f"Error in launch detection: {e}")
                 try:
                     while True:
                         time.sleep(1)
                 except KeyboardInterrupt:
                     print("\nServer stopped")
-            else:
-                # Note for non-blocking mode
-                print("\nNote: Server is running in a background thread. To keep it alive, either:")
-                print("1. Set blocking=True when calling launch()")
-                print("2. Keep your main application running")
-                print("3. Use a loop in your code to prevent the program from exiting")
-            
+        
         return None 

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.78"
+version = "0.0.79"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }

src/praisonai-agents/uv.lock

@@ -1883,7 +1883,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.78"
+version = "0.0.79"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },