Initial Project structure

.devcontainer/devcontainer.json

@@ -0,0 +1,40 @@
+{
+    "name": "Expressly AI Agent",
+    // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+    "image": "python:3.12-slim",
+    "features": {
+        "ghcr.io/devcontainers/features/python:1": {
+            "version": "3.12"
+        },
+        "ghcr.io/devcontainers/features/git:1": {},
+        "ghcr.io/devcontainers/features/docker-in-docker:2.12.0": {
+            "version": "latest",
+            "moby": true
+        }
+    },
+    // Use 'postCreateCommand' to run commands after the container is created.
+    "postCreateCommand": "./.devcontainer/postCreateCommand.sh",
+    "forwardPorts": [
+        7860,
+        80
+    ],
+    // Configure tool-specific properties.
+    "customizations": {
+        "vscode": {
+            "extensions": [
+                "ms-python.python",
+                "editorconfig.editorconfig",
+                "ms-azuretools.vscode-docker", // Docker
+                "ms-python.isort", // isort
+                "visualstudioexptteam.vscodeintellicode", // IntelliCode
+                "codeium.codeium", // Codeium AI
+                "ms-vscode.makefile-tools", // Makefile tool
+                "ms-python.python", // Python
+                "ms-python.black-formatter", // Black
+                "ms-python.debugpy", // Debugger for Python
+                "redhat.vscode-yaml", // YAML
+                "tamasfe.even-better-toml" // TOML
+            ]
+        }
+    }
+}

.devcontainer/postCreateCommand.sh

@@ -0,0 +1,11 @@
+#! /usr/bin/env bash
+
+# Install fish terminal
+sudo apt update -y
+sudo apt-get install fish -y
+
+# Repo Initialization
+git config --global --add safe.directory /workspaces/expressly
+
+# Install Dependencies
+pip install crewai

.dockerignore

@@ -0,0 +1,68 @@
+# Byte-compiled Python files
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.pytest_cache/
+.mypy_cache/
+
+# Environment variables and config files
+.env
+.env.*
+
+# Virtual environment directories
+venv/
+env/
+.virtualenv/
+.venv/
+
+# System files
+.DS_Store
+Thumbs.db
+
+# Logs and debug files
+*.log
+*.out
+*.err
+
+# Cache and coverage files
+*.egg-info/
+.eggs/
+*.cache
+*.coverage
+.coverage.*
+.cache/
+.pytest_cache/
+nosetests.xml
+coverage.xml
+.ruff_cache/
+
+# Build files and directories
+build/
+dist/
+*.egg
+*.whl
+
+# Temporary files
+*.swp
+*.swo
+*.bak
+*.tmp
+
+# Docker-specific files
+docker-compose.override.yml
+
+# Other files to exclude
+.idea/
+.vscode/
+*.iml
+.DS_Store
+
+# Git files
+.git
+.github
+.gitignore
+.gitattributes
+
+# Other files
+uv.lock

.env.example

@@ -0,0 +1,2 @@
+MODEL=gemini/gemini-1.5-flash
+GEMINI_API_KEY=<gemini_api_key> # Your API key here

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/build-container.yml

@@ -0,0 +1,33 @@
+name: Build and Deploy Docker Image
+
+on:
+    workflow_dispatch: {}
+    push:
+        branches:
+            - main # or master, depending on your default branch
+
+env:
+    DOCKER_IMAGE: deepak93p/expressly-app # Replace with your DockerHub image
+
+
+jobs:
+    build-push-docker-image:
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Login to Docker Hub
+              env:
+                  DOCKER_USER: deepak93p
+                  DOCKER_PWD: ${{ secrets.DOCKERHUB_PUSH_TOKEN }}
+              run: echo $DOCKER_PWD | docker login -u $DOCKER_USER --password-stdin
+
+            - name: Build and Push Docker Image
+              run: |
+                docker build -t ${{ env.DOCKER_IMAGE }}:latest -f Dockerfile .
+                docker push ${{ env.DOCKER_IMAGE }}:latest
+                
+            - name: Clean up Docker system
+              run: docker system prune -f

.github/workflows/hugging_face-deploy.yml

@@ -0,0 +1,28 @@
+name: Deploy to Hugging Face Spaces
+
+on:
+    workflow_dispatch: {}
+    push:
+        branches:
+            - main # or master, depending on your default branch
+
+jobs:
+    deploy:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+              with:
+                  fetch-depth: 0
+
+            - name: Configure Git
+              run: |
+                  git config --global user.email "github-actions[bot]@users.noreply.github.com"
+                  git config --global user.name "github-actions[bot]"
+
+            - name: Push to Hugging Face Space
+              env:
+                  HF_TOKEN: ${{ secrets.HF_TOKEN }}
+              run: |
+                  git remote add space https://USER:[email protected]/spaces/deepakpant/expressly-app
+                  git push --force space main

.gitignore

@@ -0,0 +1,2 @@
+.env
+__pycache__/

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: expressly",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/src/expressly_server/web_app.py",
+            "args": ["run"],
+            "console": "integratedTerminal",
+            "justMyCode": true,
+            "jinja": true
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+    "files.exclude": {
+        "**/.mypy_cache": true,
+        "**/__pycache__": true,
+        "**/.pytest_cache": true,
+        "**/.ruff_cache": true,
+        "**/.venv": true,
+        "**/venv": true,
+        "**/node_modules": true,
+        "**/site": true,
+        "**/.coverage": true,
+        "**/coverage.xml": true,
+        "**/build": true,
+        "**/dist": true
+    }
+}

Dockerfile

@@ -0,0 +1,49 @@
+# Use an official Python image as a base
+FROM python:3.12-slim
+
+RUN useradd -m -u 1000 user
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    gcc \
+    libssl-dev \
+    pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Rust (required for orjson and other Rust-based Python packages)
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \
+    && export PATH="$HOME/.cargo/bin:$PATH" \
+    && rustc --version
+
+# Ensure Rust is added to PATH for all subsequent RUN commands
+ENV PATH="/root/.cargo/bin:$PATH"
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy the pyproject.toml and any other build-related files
+COPY --chown=user pyproject.toml .
+
+
+# Install dependencies
+RUN pip install --upgrade pip \
+    && pip install uv crewai \
+    && crewai install
+
+# Ensure the /app directory is owned by the non-root user
+RUN chown -R user:user /app
+
+# Switch to the non-root user
+USER user
+
+# Copy the application code into the container
+COPY --chown=user . .
+
+EXPOSE 7860
+
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# Define the command to run your application
+CMD ["uv", "run", "expressly"]

README.md

@@ -0,0 +1,68 @@
+---
+title: Expressly
+emoji: 🛠️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+license: mit
+short_description: Expressly - Text Transformation App
+---
+
+# Expressly - Text Transformation App Backend
+
+This document provides an overview of the backend server for the Expressly - Text Transformation App. The app is designed to transform text based on user preferences and descriptions, leveraging a CrewAI-based multi-agent AI application.
+
+## Key Features
+
+### Text Transformation Options
+The backend supports the following transformation capabilities:
+1. **Formats**
+   - For details on supported formats, please refer to the [Expressly Wiki](https://github.com/DeepakPant93/expressly/wiki).
+
+2. **Tones**
+   - For details on supported tones, please refer to the [Expressly Wiki](https://github.com/DeepakPant93/expressly/wiki).
+
+3. **Target Audience**
+   - For details on supported target audiences, please refer to the [Expressly Wiki](https://github.com/DeepakPant93/expressly/wiki).
+
+### Output
+The backend processes user inputs and generates formatted text tailored to the specified preferences. Users can easily copy and utilize the output.
+
+## Backend Configuration
+
+### Prerequisites
+1. Install `uv` if not already installed:
+   ```bash
+   pip install uv
+   ```
+2. Navigate to your project directory and install dependencies:
+   ```bash
+   crewai install
+   ```
+   (Optional: Lock dependencies using the CLI command.)
+
+### Customization
+1. Add environment variables to the `.env` file:
+   ```plaintext
+   MODEL=gemini/gemini-1.5-flash
+   GEMINI_API_KEY=<gemini_api_key> # Your API key here
+   ```
+2. Modify configuration files as needed:
+   - `src/expressly_server/config/agents.yaml`: Define your agents.
+   - `src/expressly_server/config/tasks.yaml`: Define your tasks.
+   - `src/expressly_server/crew.py`: Add custom logic, tools, and arguments.
+   - `src/expressly_server/main.py`: Customize inputs for agents and tasks.
+
+### Running the Backend
+To start the backend server and execute tasks:
+```bash
+crewai run
+```
+
+## Additional Notes
+- Ensure all environment variables are correctly set in the `.env` file.
+- Regularly update your agents and tasks configuration to enhance functionality.
+- Refer to the CrewAI documentation for advanced customizations.
+
+This backend server powers the text transformation capabilities of Expressly, making it adaptable to a wide range of use cases.

knowledge/content_style_mapping.json

@@ -0,0 +1,48 @@
+{
+    "target_audience": {
+      "linkedin_post": {
+        "format": "post",
+        "tone": "professional"
+      },
+      "whatsapp_message": {
+        "format": "chat",
+        "tone": "casual"
+      },
+      "tweet": {
+        "format": "tweet",
+        "tone": "straightforward"
+      },
+      "news_article": {
+        "format": "article",
+        "tone": "neutral"
+      },
+      "technical_blog": {
+        "format": "blog",
+        "tone": "professional"
+      },
+      "formal_email": {
+        "format": "email",
+        "tone": "professional"
+      },
+      "instagram_post": {
+        "format": "post",
+        "tone": "friendly"
+      },
+      "website_content": {
+        "format": "report",
+        "tone": "neutral"
+      },
+      "marketing_email": {
+        "format": "email",
+        "tone": "confident"
+      },
+      "job_application": {
+        "format": "email",
+        "tone": "professional"
+      },
+      "customer_support_response": {
+        "format": "chat",
+        "tone": "friendly"
+      }
+    }
+  }

knowledge/format.json

@@ -0,0 +1,46 @@
+{
+  "format": {
+    "post": {
+      "name": "Post",
+      "description": "A short and engaging content piece, often used for platforms like LinkedIn or Facebook. It highlights key points and encourages interaction, such as likes, shares, or comments.",
+      "max_length": 300,
+      "negative": "Avoid long paragraphs, excessive technical jargon, or overly formal language. Do not make the content too detailed or complex."
+    },
+    "chat": {
+      "name": "Chat",
+      "description": "A conversational and interactive response that mimics real-time messaging. It focuses on direct, clear, and natural communication with a friendly tone.",
+      "max_length": 200,
+      "negative": "Do not use overly formal language, complex sentence structures, or impersonal tones. Avoid too much technical information and hashtags."
+    },
+    "tweet": {
+      "name": "Tweet",
+      "description": "A concise and impactful message designed for Twitter or similar platforms. It often uses hashtags, mentions, or trending topics to increase visibility.",
+      "max_length": 280,
+      "negative": "Avoid lengthy explanations, irrelevant details, or complex sentences. Do not exceed the character limit or use a formal tone."
+    },
+    "email": {
+      "name": "Email",
+      "description": "A formal or semi-formal written message for direct communication. It includes a clear subject line, opening, body, and closing, often addressing specific recipients.",
+      "max_length": 1500,
+      "negative": "Avoid casual or overly brief content. Do not make the email too long or include excessive details that deviate from the purpose."
+    },
+    "blog": {
+      "name": "Blog",
+      "description": "A detailed and informative piece written for online readers. It includes a compelling introduction, multiple sections with headings, and a conclusion to engage and educate the audience.",
+      "max_length": 2000,
+      "negative": "Avoid overly technical language, jargon, or too formal language. Do not make the blog too short or lacking in detail."
+    },
+    "article": {
+      "name": "Article",
+      "description": "A comprehensive, well-researched write-up, often featuring in-depth analysis or expert perspectives. Suitable for magazines, websites, or journals to inform or persuade a broad audience.",
+      "max_length": 3000,
+      "negative": "Do not oversimplify complex topics, avoid using unverified sources or vague statements. Avoid making the article too conversational or informal."
+    },
+    "report": {
+      "name": "Report",
+      "description": "A structured document that presents facts, data, and analysis for a specific audience or purpose. It often includes charts, tables, and a clear summary of findings.",
+      "max_length": 5000,
+      "negative": "Avoid informal language, speculative content, or a lack of data. Do not make the report subjective or unorganized."
+    }
+  }
+}

knowledge/target_audience.json

@@ -0,0 +1,59 @@
+{
+    "target_audience": {
+      "linkedin_post": {
+        "name": "LinkedIn Post",
+        "description": "Aimed at professionals, thought leaders, and businesses. Content is typically career-focused or industry-related, designed to spark engagement among people seeking professional growth, networking, or knowledge.",
+        "ideal_audience": "Business professionals, marketers, entrepreneurs, recruiters, job seekers, industry experts"
+      },
+      "whatsapp_message": {
+        "name": "WhatsApp Message",
+        "description": "Casual or semi-formal communication meant for direct, personal messaging. Used for sending quick updates, reminders, or messages to small groups, often informal in tone.",
+        "ideal_audience": "Friends, family, small teams, personal contacts, colleagues in a more relaxed setting"
+      },
+      "tweet": {
+        "name": "Tweet",
+        "description": "Aimed at a broad, diverse audience on Twitter, from the general public to niche communities. Tweets are brief and designed to provoke quick engagement, whether through likes, retweets, or comments.",
+        "ideal_audience": "General public, influencers, content creators, tech enthusiasts, trend followers, entertainment fans"
+      },
+      "news_article": {
+        "name": "News Article",
+        "description": "Targeted at a wide audience seeking timely, relevant information. News articles are often written for readers who are looking for the latest updates, in-depth analysis, or expert opinions on current events or trending topics.",
+        "ideal_audience": "General public, journalists, news enthusiasts, academics, policy makers, professionals interested in current affairs"
+      },
+      "technical_blog": {
+        "name": "Technical Blog",
+        "description": "Aimed at professionals, experts, or hobbyists in specialized fields like technology, software development, engineering, or data science. The content is typically in-depth, offering insights, tutorials, and technical knowledge.",
+        "ideal_audience": "Software developers, engineers, data scientists, tech entrepreneurs, IT professionals, learners seeking advanced technical skills"
+      },
+      "formal_email": {
+        "name": "Formal Email",
+        "description": "Designed for business or professional communication. The email is meant for communicating with colleagues, clients, business partners, or supervisors in a polite, respectful, and formal tone.",
+        "ideal_audience": "Business professionals, corporate partners, clients, managers, senior leadership, job candidates"
+      },
+      "instagram_post": {
+        "name": "Instagram Post",
+        "description": "Aimed at a visually-driven, creative audience. Instagram posts are often used for branding, lifestyle content, promotions, or personal expression, with a focus on imagery and concise captions.",
+        "ideal_audience": "Millennials, Gen Z, influencers, lifestyle bloggers, fashion enthusiasts, foodies, beauty influencers, brand followers"
+      },
+      "website_content": {
+        "name": "Website Content",
+        "description": "Targeted at a broad range of users, from potential customers to casual visitors. Website content needs to be informative, engaging, and easily navigable, with a focus on conversion and user experience.",
+        "ideal_audience": "Consumers, visitors, potential customers, search engine users, anyone looking for information or services"
+      },
+      "marketing_email": {
+        "name": "Marketing Email",
+        "description": "Aimed at potential customers or existing leads. Marketing emails are designed to drive action, whether it’s to purchase a product, sign up for a service, or engage with a special offer.",
+        "ideal_audience": "Prospective customers, leads, subscribers, clients, consumers interested in sales promotions"
+      },
+      "job_application": {
+        "name": "Job Application",
+        "description": "Directed towards hiring managers, recruiters, or HR professionals. The job application content should clearly convey qualifications, skills, and the applicant's interest in a specific role.",
+        "ideal_audience": "Recruiters, hiring managers, HR professionals, employers, staffing agencies"
+      },
+      "customer_support_response": {
+        "name": "Customer Support Response",
+        "description": "Meant for existing or potential customers seeking assistance with a product or service. The tone should be empathetic, understanding, and solution-oriented, addressing the customer’s issue in a clear, helpful manner.",
+        "ideal_audience": "Customers with inquiries, complaints, technical issues, or service requests"
+      }
+    }
+  }

knowledge/tone.json

@@ -0,0 +1,36 @@
+{
+    "tone": {
+      "professional": {
+        "name": "Professional",
+        "description": "Formal and respectful, suited for workplace communication."
+      },
+      "casual": {
+        "name": "Casual",
+        "description": "Relaxed and conversational, suitable for informal interactions."
+      },
+      "straightforward": {
+        "name": "Straightforward",
+        "description": "Direct and concise, avoiding unnecessary details."
+      },
+      "confident": {
+        "name": "Confident",
+        "description": "Assertive and positive, showing conviction in the message."
+      },
+      "friendly": {
+        "name": "Friendly",
+        "description": "Warm and approachable, making the user feel comfortable."
+      },
+      "neutral": {
+        "name": "Neutral",
+        "description": "Objective and balanced, without bias or emotion."
+      },
+      "storytelling": {
+        "name": "Storytelling",
+        "description": "Narrative style, weaving details into a compelling story."
+      },
+      "inspirational": {
+        "name": "Inspirational",
+        "description": "Uplifting and encouraging, motivating the user."
+      }
+    }
+  }

pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "expressly_server"
+version = "0.1.0"
+description = "expressly-server using crewAI"
+authors = [{ name = "Deepak Pant", email = "[email protected]" }]
+requires-python = ">=3.10,<=3.13"
+dependencies = [
+    "crewai[tools]>=0.86.0,<1.0.0",
+    "gradio>=5.12.0,<5.13.0"
+]
+
+[project.scripts]
+expressly = "expressly_server.web_app:launch"
+run_crew = "expressly_server.main:run"
+train = "expressly_server.main:train"
+replay = "expressly_server.main:replay"
+test = "expressly_server.main:test"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

src/expressly_server/app.py

@@ -0,0 +1,69 @@
+from fastapi import FastAPI, responses
+from fastapi.openapi.utils import get_openapi
+from expressly_server.routers.route import router
+
+__version__ = "0.0.1"
+
+app = FastAPI(
+    title="Expressly AI Server",
+    description="Expressly is your ultimate tool for transforming text effortlessly.",
+    version=__version__,
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+
+app = FastAPI()
+
+
+@app.get("/", include_in_schema=False)
+async def root() -> responses.RedirectResponse:
+    """
+    Redirects the root URL to the API documentation page.
+
+    Returns:
+        RedirectResponse: A response object that redirects the client to the "/docs" URL.
+    """
+
+    return responses.RedirectResponse("/docs")
+
+# Include routers
+app.include_router(router, prefix="/app/v1", tags=["Operations"])
+
+
+def _custom_openapi() -> dict:
+    if app.openapi_schema:
+        return app.openapi_schema
+    openapi_schema = get_openapi(
+        title="Expressly AI Server",
+        description="Expressly is your ultimate tool for transforming text effortlessly.",
+        version=__version__,
+        routes=app.routes,
+    )
+    app.openapi_schema = openapi_schema
+    return app.openapi_schema
+
+
+app.openapi = _custom_openapi
+
+
+def main() -> None:
+    """
+    The main entry point of the application.
+
+    This function starts the FastAPI server using Uvicorn. It serves the API
+    on the specified host and port. The function is intended to be run
+    directly when the script is executed.
+
+    Notes:
+        - The 'nosec B104' comment is used to suppress a security warning
+          related to binding to all network interfaces.
+    """
+
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=10000)
+
+
+if __name__ == "__main__":
+    main()

src/expressly_server/config/agents.yaml

@@ -0,0 +1,10 @@
+content_creator:
+  role: >
+    Senior Content Creator
+  goal: >
+    Created engaging and informative content
+  backstory: >
+    You're a seasoned content creator with a knack for producing high-quality
+    content that captivates and educates your audience. You're known for your
+    ability to translate complex concepts into clear and engaging narratives,
+    making it easy for others to learn and understand.

src/expressly_server/config/tasks.yaml

@@ -0,0 +1,40 @@
+content_creator_task:
+  description: >
+    Understand the context carefully
+    
+    ---
+    Context:
+    ({context})
+    ---
+
+    Describe the context in a way that would follow the tone, format, and guidelines provided.
+
+    ---
+    Tone:(
+    [Tone: {tone[name]}] ###  
+    [Tone Description: {tone[description]}] ### 
+    )
+    ---
+
+    ---
+    Format:(
+    [Format Type: {format[name]}] ### 
+    [Format Description:{format[description]}] ### 
+    [Max Content Length: {format[max_length]}] ### 
+    [Negetive: {format[negative]}])
+    )
+    ---
+
+    ---
+    Target Audience: (
+    [Target Audience: {target_audience[name]}] ### 
+    [Target Audience Description: {target_audience[description]}] ### 
+    [Ideal Audience Description: {target_audience[ideal_audience]}] ### 
+    )
+    ---
+
+    Make sure you find the latest information about the topic in the internet if needed and provide a well-researched content.
+  expected_output: >
+    A fully fledge output with the desised format & tone and the the Guidelines provided in the description.
+    Formatted as markdown without '```'
+  agent: content_creator

src/expressly_server/crew.py

@@ -0,0 +1,164 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task, before_kickoff
+from crewai.llm import LLM
+from crewai.knowledge.source.json_knowledge_source import JSONKnowledgeSource
+from dotenv import load_dotenv
+import os
+from typing import Dict, Any, Optional
+import json
+from expressly_server.utils.utils import load_json_data, sanitize_input
+
+load_dotenv()
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+MODEL = os.getenv("MODEL")
+
+FORMAT_JSON_FILE = "format.json"
+TONE_JSON_FILE = "tone.json"
+TARGET_AUDIENCE_JSON_FILE = "target_audience.json"
+CONTENT_STYLE_MAPPING_JSON_FILE = "content_style_mapping.json"
+KNOWLEDGE_SOURCE_PATH = "knowledge"
+
+
+@CrewBase
+class ExpresslyServer:
+    """ExpresslyServer crew"""
+
+    # Create a knowledge source
+    json_knowledge_source = JSONKnowledgeSource(
+        file_paths=["format.json", "tone.json", "target_audience.json"],
+    )
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    llm = LLM(model=MODEL, api_key=GEMINI_API_KEY, temperature=0.7)
+
+    @before_kickoff
+    def validate_inputs(
+        self, inputs: Optional[Dict[str, Any]]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Validate and process user inputs based on the active tab selection.
+
+        This method checks the integrity and presence of required inputs, loads
+        necessary JSON data, and validates the active_tab value to ensure the
+        appropriate fields are populated. It formats the inputs for further processing.
+
+        Parameters:
+        inputs (Optional[Dict[str, Any]]): The dictionary containing user inputs,
+        including 'target_audience', 'format', 'tone', 'active_tab', and 'prompt'.
+
+        Returns:
+        Optional[Dict[str, Any]]: A dictionary formatted with context, format, tone,
+        and target_audience details based on the inputs provided.
+
+        Raises:
+        ValueError: If inputs are missing, not a dictionary, or required fields
+        ('active_tab', 'prompt', 'format', 'tone', 'target_audience') are not provided
+        or invalid.
+        """
+
+        if inputs is None or len(inputs) == 0 or not isinstance(inputs, dict):
+            raise ValueError("Inputs is required and must be a dictionary")
+
+        ## Get the first element from the list of inputs and get the value of target, format, active_tab and prompt
+        query = inputs
+        target_audience: str = sanitize_input(query.get("target_audience"))
+        content_format: str = sanitize_input(query.get("format"))
+        content_tone: str = sanitize_input(query.get("tone"))
+        prompt: str = query.get("prompt")
+
+        # Check if prompt are not None
+        if prompt is None:
+            raise ValueError("Prompt is required")
+
+        # Load JSON data from content_style_mapping.json
+        content_style_mapping_json = load_json_data(
+            CONTENT_STYLE_MAPPING_JSON_FILE, KNOWLEDGE_SOURCE_PATH
+        )
+        tone_json = load_json_data(TONE_JSON_FILE, KNOWLEDGE_SOURCE_PATH)
+        format_json = load_json_data(FORMAT_JSON_FILE, KNOWLEDGE_SOURCE_PATH)
+        target_audience_json = load_json_data(
+            TARGET_AUDIENCE_JSON_FILE, KNOWLEDGE_SOURCE_PATH
+        )
+
+        if target_audience != "":
+            ## Resetting the format and tone as per the target audience
+            mappings: dict = content_style_mapping_json.get("target_audience").get(
+                target_audience
+            )
+            format_dict = format_json.get("format").get(mappings.get("format"))
+            tone_dict = tone_json.get("tone").get(mappings.get("tone"))
+            target_audience_dict = target_audience_json.get("target_audience").get(
+                target_audience
+            )
+        elif content_format != "" and content_tone != "":
+            ## Constructing a target_audience_dict with empty values and populating the format and tone as per the input
+            target_audience_dict = {
+                "name": "",
+                "description": "",
+                "ideal_audience": "",
+            }
+            format_dict = format_json.get("format").get(content_format)
+            tone_dict = tone_json.get("tone").get(content_tone)
+        else:
+            raise ValueError("Provide either target audience or format and tone")
+
+        ## Format the inputs
+        inputs = {
+            "context": prompt,
+            "format": format_dict,
+            "tone": tone_dict,
+            "target_audience": target_audience_dict,
+        }
+
+        return inputs
+
+    @agent
+    def content_creator(self) -> Agent:
+        """
+        Initializes and returns an Agent for content creation.
+
+        This agent is configured using predefined settings for the content creator
+        and utilizes a language model (LLM) for generating content. The agent
+        accesses a JSON knowledge source to enhance its capabilities and operates
+        in verbose mode for detailed output logging.
+
+        Returns:
+            Agent: An initialized agent configured for content creation.
+        """
+
+        return Agent(
+            config=self.agents_config["content_creator"],
+            llm=self.llm,
+            knowledge_source=[self.json_knowledge_source],
+            verbose=True,
+        )
+
+    @task
+    def content_creator_task(self) -> Task:
+        """
+        Initializes and returns a Task for content creation.
+
+        This task is configured using predefined settings for content creation
+        and is used by the content creator agent to generate content.
+
+        Returns:
+            Task: An initialized task configured for content creation.
+        """
+        return Task(
+            config=self.tasks_config["content_creator_task"],
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the ExpresslyServer crew"""
+
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            knowledge_source=[self.json_knowledge_source],
+            verbose=True,
+        )

src/expressly_server/main.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+import sys
+import warnings
+
+from expressly_server.crew import ExpresslyServer
+import dotenv
+
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
+
+dotenv.load_dotenv()
+
+
+def run():
+    """
+    Run the crew.
+    """
+
+    inputs = {
+        "prompt": "I want to thanks DeepLearning and John from the crewAI for this amazing course..",
+        "format": "Email",
+        "tone": "Friendly",
+        "target_audience": "",
+    }
+
+    ExpresslyServer().crew().kickoff(inputs=inputs)
+
+
+def train():
+    """
+    Train the crew for a given number of iterations.
+    """
+    inputs = {"topic": "AI LLMs"}
+    try:
+        ExpresslyServer().crew().train(
+            n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs
+        )
+
+    except Exception as e:
+        raise Exception(f"An error occurred while training the crew: {e}")
+
+
+def replay():
+    """
+    Replay the crew execution from a specific task.
+    """
+    try:
+        ExpresslyServer().crew().replay(task_id=sys.argv[1])
+
+    except Exception as e:
+        raise Exception(f"An error occurred while replaying the crew: {e}")
+
+
+def test():
+    """
+    Test the crew execution and returns the results.
+    """
+    inputs = {"topic": "AI LLMs"}
+    try:
+        ExpresslyServer().crew().test(
+            n_iterations=int(sys.argv[1]), openai_model_name=sys.argv[2], inputs=inputs
+        )
+
+    except Exception as e:
+        raise Exception(f"An error occurred while replaying the crew: {e}")

src/expressly_server/routers/route.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from expressly_server.crew import ExpresslyServer
+from expressly_server.schemas.schema import ChatInput, ChatOutput
+from fastapi import HTTPException
+
+
+router = APIRouter()
+
+
+@router.post("/chat")
+async def chat(inputs: ChatInput) -> ChatOutput:
+
+    result = None
+
+    try:
+        outputs = ExpresslyServer().crew().kickoff(inputs=inputs.model_dump())
+
+        if outputs is None:
+            result = "Please check the inputs and try again. If the issue persists, contact support."
+        else:
+            result = outputs.raw
+    except ValueError as ve:
+        raise ValueError(f"Value error occurred: {ve}")
+    except Exception as e:
+        print(f"An Internal server error occurred: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error: Please try again later.")
+
+    return ChatOutput(result=result)

src/expressly_server/schemas/schema.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel
+from pydantic.fields import Field
+from typing import Optional
+
+
+class ChatInput(BaseModel):
+    prompt: str = Field(
+        ..., min_length=5, max_length=1000, description="The text prompt for the chat"
+    )
+    format: Optional[str] = Field(
+        None, description="The format of the response, e.g., text, markdown"
+    )
+    tone: Optional[str] = Field(
+        None, description="The tone of the response, e.g., formal, informal"
+    )
+    target_audience: Optional[str] = Field(
+        None, description="The target audience for the response"
+    )
+
+
+class ChatOutput(BaseModel):
+    result: str = Field(..., description="The transformed text response")

src/expressly_server/utils/utils.py

@@ -0,0 +1,33 @@
+import json
+
+
+def load_json_data(file_name: str, file_path: str) -> dict:
+    """
+    Loads JSON data from a file.
+
+    Args:
+        file_name (str): The name of the JSON file.
+        file_path (str): The path to the directory containing the file.
+
+    Returns:
+        dict: The content of the JSON file as a dictionary.
+    """
+
+    file_path = f"{file_path}/{file_name}"
+    with open(file_path, "r") as file:
+        return json.load(file)
+
+
+def sanitize_input(input: str) -> str:
+    """
+    Sanitizes a string by stripping, lower casing, and replacing whitespace and hyphens with underscores.
+
+    Args:
+        input (str): The string to be sanitized.
+
+    Returns:
+        str: The sanitized string.
+    """
+    if input is None or input == "":
+        return ""
+    return input.strip().lower().replace(" ", "_").replace("-", "_")

src/expressly_server/web_app.py

@@ -0,0 +1,150 @@
+import gradio as gr
+import os
+from expressly_server.crew import ExpresslyServer
+
+
+def call(prompt, target_audience, format, tone, active_tab):
+    """
+    Calls the Expressly Server API to generate content based on the given inputs.
+
+    Args:
+    prompt (str): The text prompt for the chat.
+    target_audience (str): The target audience for the response.
+    format (str): The format of the response, e.g., text, markdown.
+    tone (str): The tone of the response, e.g., formal, informal.
+    active_tab (str): The active tab on the UI, either "target_audience" or "format_tone".
+
+    Returns:
+    str: The generated text response.
+
+    Raises:
+    ValueError: If prompt is empty, or if the active_tab value is invalid.
+    """
+
+    # Validating and constructing the inputs
+    if prompt is None or prompt == "":
+        raise ValueError("Prompt is required")
+
+    if active_tab == "target_audience":
+        format = ""
+        tone = ""
+    elif active_tab == "format_tone":
+        target_audience = ""
+    else:
+        raise ValueError("Invalid active_tab value")
+
+    inputs = {
+        "prompt": prompt,
+        "target_audience": target_audience,
+        "format": format,
+        "tone": tone,
+    }
+
+    outputs = ExpresslyServer().crew().kickoff(inputs=inputs)
+
+    if outputs is None:
+        result = "Please check the inputs and try again. If the issue persists, contact support."
+    else:
+        result = outputs.raw
+
+    return result
+
+
+with gr.Blocks() as app:
+    gr.Markdown("# Expressly - Text Transformation App")
+
+    with gr.Row():
+        # Left Column for Inputs
+        with gr.Column(scale=1):
+            prompt = gr.Textbox(label="Message Expressly", max_length=1024, lines=3)
+
+            # Create a state variable to store active tab
+            active_tab = gr.State("target_audience")
+
+            with gr.Tab("Target Audience", id="tab_audience") as tab1:
+                target_audience = gr.Dropdown(
+                    [
+                        "LinkedIn Post",
+                        "WhatsApp Message",
+                        "Tweet",
+                        "News Article",
+                        "Technical Blog",
+                        "Formal Email",
+                        "Instagram Post",
+                        "Website Content",
+                        "Marketing Email",
+                        "Job Application",
+                        "Customer Support Response",
+                    ],
+                    label="Target Audience",
+                    info="Pick a Target Audience to specify the purpose or platform.",
+                )
+                # Update state when this tab is selected
+                tab1.select(lambda: "target_audience", None, active_tab)
+
+            with gr.Tab("Format & Tone", id="tab_format") as tab2:
+                format = gr.Dropdown(
+                    [
+                        "Post",
+                        "Chat",
+                        "Tweet",
+                        "Email",
+                        "Blog",
+                        "Article",
+                        "Report",
+                        "Product Description",
+                    ],
+                    label="Format",
+                    info="Choose a Format to define the type of content.",
+                )
+                tone = gr.Dropdown(
+                    [
+                        "Professional",
+                        "Casual",
+                        "Straightforward",
+                        "Confident",
+                        "Friendly",
+                        "Neutral",
+                        "Storytelling",
+                        "Inspirational",
+                    ],
+                    label="Tone",
+                    info="Select a Tone to set the communication style.",
+                )
+                # Update state when this tab is selected
+                tab2.select(lambda: "format_tone", None, active_tab)
+
+            btn_submit = gr.Button("Submit")
+
+        # Right Column for Output
+        with gr.Column(scale=1):
+            results = gr.Markdown(label="Result")
+
+    btn_submit.click(
+        fn=call,
+        inputs=[prompt, target_audience, format, tone, active_tab],
+        outputs=[results],
+    )
+
+
+def launch():
+    """
+    Launch the Expressly web app.
+
+    This function starts the Expressly web app in a threaded mode, allowing it
+    to process multiple requests concurrently. The app is configured to
+    accept up to 10 requests in its queue at any given time.
+
+    The app is launched with strict CORS checks disabled, which allows it
+    to be accessed from any origin.
+
+    To launch the app, call this function with no arguments.
+
+    Example:
+        launch()
+    """
+    app.queue(max_size=10).launch(strict_cors=False)
+
+
+if __name__ == "__main__":
+    launch()