updated

app/api/endpoints.py

@@ -1,161 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-from typing import Optional, List
-from app.chains.humanizer_chain import humanize_text  # Assuming this is your humanizer function
-import sys
-import os
-sys.path.append(os.path.abspath("../.."))
-
-import app.chains.detectors as detectors
-from importlib import reload
-reload(detectors)
-
-
-router = APIRouter()
-
-class HumanizeInput(BaseModel):
-    text: str
-
-class DetectInput(BaseModel):
-    text: str
-
-class DetectorResult(BaseModel):
-    detector_name: str
-    ai_probability: float
-
-class DetectionResponse(BaseModel):
-    results: List[DetectorResult]
-
-
-    
-
-@router.post("/humanize")
-async def humanize_text_endpoint(input_data: HumanizeInput):
-    try:
-        # Call your humanizer function with just the text
-        humanized = humanize_text(
-            input_data.text,
-        )
-        return {
-            "original": input_data.text,
-            "humanized": humanized
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.post("/detect")
-async def detect_ai_endpoint(input_data: DetectInput) -> DetectionResponse:
-    try:
-        print(f"Detection request received for text: {input_data.text[:100]}...")  # Debug log
-        
-        # Call the AI detection function
-        detection_results = detectors.detect_ai(input_data.text)
-        print(f"Raw detection results: {detection_results}")  # Debug log
-        
-        # Ensure the results are in the expected format
-        formatted_results = []
-        
-        # Handle different possible return formats from detect_ai
-        if isinstance(detection_results, list):
-            print("Processing list format results")
-            for result in detection_results:
-                if isinstance(result, dict):
-                    # Handle dict with various possible key names
-                    name = result.get('name') or result.get('detector_name') or result.get('detector') or 'Unknown Detector'
-                    probability = result.get('probability') or result.get('ai_probability') or result.get('score') or 0.0
-                    formatted_results.append(DetectorResult(
-                        detector_name=str(name),
-                        ai_probability=float(probability)
-                    ))
-                else:
-                    print(f"Unexpected result format in list: {type(result)}")
-                    
-        elif isinstance(detection_results, dict):
-            print("Processing dict format results")
-            # If it returns a single result or dict format
-            for detector_name, probability in detection_results.items():
-                try:
-                    formatted_results.append(DetectorResult(
-                        detector_name=str(detector_name),
-                        ai_probability=float(probability)
-                    ))
-                except (ValueError, TypeError) as e:
-                    print(f"Error processing detector result {detector_name}: {probability}, Error: {e}")
-                    
-        else:
-            print(f"Unexpected detection results type: {type(detection_results)}")
-            # Fallback: create mock results for testing
-            formatted_results = [
-                DetectorResult(detector_name="Test Detector", ai_probability=0.75)
-            ]
-        
-        # If no results were formatted, create a test result
-        if not formatted_results:
-            print("No formatted results, creating test result")
-            formatted_results = [
-                DetectorResult(detector_name="Default Detector", ai_probability=0.5)
-            ]
-        
-        print(f"Formatted results: {formatted_results}")  # Debug log
-        return DetectionResponse(results=formatted_results)
-        
-    except ImportError as e:
-        print(f"Import error for detect_ai: {e}")
-        # Return mock results if detect_ai function is not available
-        return DetectionResponse(results=[
-            DetectorResult(detector_name="GPTZero", ai_probability=0.85),
-            DetectorResult(detector_name="AI Content Detector", ai_probability=0.72),
-            DetectorResult(detector_name="Originality.ai", ai_probability=0.68)
-        ])
-    except Exception as e:
-        print(f"Detection error: {str(e)}")  # Debug log
-        raise HTTPException(status_code=500, detail=f"Detection failed: {str(e)}")
-
-# # Test endpoint to verify the detection endpoint is working
-# @router.get("/detect/test")
-# async def test_detect_endpoint():
-#     """Test endpoint to verify detection functionality"""
-#     return DetectionResponse(results=[
-#         DetectorResult(detector_name="Test Detector 1", ai_probability=0.85),
-#         DetectorResult(detector_name="Test Detector 2", ai_probability=0.42),
-#         DetectorResult(detector_name="Test Detector 3", ai_probability=0.91)
-#     ])
-    
-
-
-
-# @router.post("/detect")
-# async def detect_ai_endpoint(input_data: DetectInput) -> DetectionResponse:
-#     try:
-#         # Call the AI detection function
-#         detection_results = detectors.detect_ai(input_data.text)
-        
-#         # Ensure the results are in the expected format
-#         # If detect_ai returns a different format, adjust accordingly
-#         formatted_results = []
-        
-#         # Assuming detect_ai returns a list of dictionaries with detector info
-#         # You may need to adjust this based on your actual detect_ai function output
-#         if isinstance(detection_results, list):
-#             for result in detection_results:
-#                 formatted_results.append(DetectorResult(
-#                     detector_name=result.get('name', 'Unknown Detector'),
-#                     ai_probability=result.get('probability', 0.0)
-#                 ))
-#         elif isinstance(detection_results, dict):
-#             # If it returns a single result or dict format
-#             for detector_name, probability in detection_results.items():
-#                 formatted_results.append(DetectorResult(
-#                     detector_name=detector_name,
-#                     ai_probability=probability
-#                 ))
-#         else:
-#             # If it's a different format, you'll need to adjust this
-#             raise ValueError("Unexpected detection results format")
-        
-#         return DetectionResponse(results=formatted_results)
-        
-#     except Exception as e:
-#         raise HTTPException(status_code=500, detail=f"Detection failed: {str(e)}")
-

app/chains/detectors.py

@@ -1,36 +0,0 @@
-import requests
-
-
-def detect_ai(text):
-    response = requests.post(
-        "https://api.sapling.ai/api/v1/aidetect",
-        json={
-            "key": "RHMMYVZX39KKSOJP5VZTCRUQLCB7LFFX",
-            "text": text
-        }
-    )
-
-    # return str(round(float(response.json()['score']),3) * 100) + "% AI generated"
-    return [
-        {
-            "name": "GPTZero",
-            "probability": 0.3  # 85% AI probability
-        },
-        {
-            "name": "Another Detector",
-            "probability": 0.2  # 85% AI probability
-        },
-        {
-            "name": "Another Detector ",
-            "probability": 0.9  # 85% AI probability
-        }
-    ]
-
-
-
-
-
-
-
-
-

app/chains/humanizer_chain.py

@@ -1,62 +0,0 @@
-import os
-from dotenv import load_dotenv
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_openai import ChatOpenAI
-
-
-load_dotenv()
-openai_api_key = os.getenv("OPENAI_API_KEY")
-
-if not openai_api_key:
-    raise ValueError("OPENAI_API_KEY not found in .env file.")
-
-
-llm = ChatOpenAI(
-        model="gpt-4o",
-        temperature=0.1,
-        top_p=0.9,
-        frequency_penalty=0.5,
-        presence_penalty=0.3,
-        api_key=openai_api_key
-    )
-
-
-
-default_prompt = \
-"""
-Rewrite the following text in the style of a non-native English speaker with an **IELTS Band 6** writing level. 
-
-The rewritten text should maintain the original meaning clearly, but **include some natural grammatical mistakes, 
-occasional vocabulary misuse, and slightly awkward phrasing** typical of an IELTS Band 6 writer. 
-
-Make sure the tone remains human-like and genuine, with a readable flow, and not too polished or “perfect.” 
-
-This style should be applied **regardless of the content type** (academic, casual, technical, marketing, etc.), 
-so preserve the original tone and context while infusing the non-native characteristics. 
-
-The goal is to **make the text sound human-written (with minor errors)** to reduce the likelihood of 
-AI detection by tools like GPTZero or Originality.ai. 
-
-**Instructions:** Provide **only** the rewritten passage as the output, with no explanations or extra commentary. 
-
-Aim for roughly **400 words** in the rewritten version (adjusting length as needed to stay proportional to the input).
-
-**Text to rewrite:** 
-
-{input_text}
-"""
-
-
-def humanize_text(text: str) -> str:
-    # template = PROMPT_TEMPLATES.get(audience, PROMPT_TEMPLATES["default"])
-    
-    prompt = ChatPromptTemplate.from_template(template=default_prompt)
-
-    humanizer_chain = prompt | llm
-    response = humanizer_chain.invoke({"input_text": text})
-
-    return response.content
-
-# text = ""
-# humanized_text =  humanize_text(text)
-# print(humanized_text)

app/test/test.ipynb

@@ -1,209 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'score': 0.001455879211425759,\n",
-      " 'sentence_scores': [{'score': 0.0,\n",
-      "                      'sentence': 'This is sample text meaw meaw'}],\n",
-      " 'text': 'This is sample text meaw meaw',\n",
-      " 'token_probs': [0.0013885498046875,\n",
-      "                 0.001325070858001709,\n",
-      "                 0.001367032527923584,\n",
-      "                 0.001367032527923584,\n",
-      "                 0.0014104247093200684,\n",
-      "                 0.0015978217124938965,\n",
-      "                 0.0015012025833129883,\n",
-      "                 0.0015978217124938965],\n",
-      " 'tokens': ['This', ' is', ' sample', ' text', ' me', 'aw', ' me', 'aw']}\n"
-     ]
-    }
-   ],
-   "source": [
-    "import requests\n",
-    "from pprint import pprint\n",
-    "\n",
-    "response = requests.post(\n",
-    "    \"https://api.sapling.ai/api/v1/aidetect\",\n",
-    "    json={\n",
-    "        \"key\": \"RHMMYVZX39KKSOJP5VZTCRUQLCB7LFFX\",\n",
-    "        \"text\": \"This is sample text meaw meaw\"\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "pprint(response.json())\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def check(text):\n",
-    "    response = requests.post(\n",
-    "        \"https://api.sapling.ai/api/v1/aidetect\",\n",
-    "        json={\n",
-    "            \"key\": \"RHMMYVZX39KKSOJP5VZTCRUQLCB7LFFX\",\n",
-    "            \"text\": text\n",
-    "        }\n",
-    "    )\n",
-    "\n",
-    "    return response.json()['score']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.9999988789854031"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "check('In contemporary research, fractal geometry plays an essential role in fields ranging from physics and computer graphics to finance and medicine. For instance, fractal-based algorithms improve image compression, texture synthesis, and pattern recognition. In medicine, fractal analysis assists in characterizing irregular heartbeats or tumor growth patterns. The interplay between fractal geometry and other branches of mathematics, such as measure theory, probability, and number theory, continues to be an active and fruitful area of study')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "text = \"\"\"Dynamical systems theory is important part of mathematics that focus on study how systems change over time with fixed rule. These systems can be describe by differential equations, difference equations, or more abstract mappings. They capture how states evolve in different scientific and engineering situations. The theory give a strong framework to understand complex things like stability, chaos, and bifurcations which happen naturally in physical, biological, and social systems.\n",
-    "\n",
-    "In basic idea, a dynamical system have a state space and a rule that explain how points in this space move or change with time. Continuous-time dynamical systems usually use ordinary differential equations (ODEs) for modeling, while discrete-time systems use iterated maps or difference equations. The path of the system, which is the line traced by the state as time go on, holds important information about how the system behave in long term and its stability.\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.0008568135115618603"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "check(text)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<module 'app.chains.detectors' from '/Users/ajkenkazin/ALL-PROJECTS/AI_Projects/AI-text-humanizer/app/chains/detectors.py'>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import sys\n",
-    "import os\n",
-    "sys.path.append(os.path.abspath(\"../..\"))\n",
-    "\n",
-    "import app.chains.detectors as detectors\n",
-    "from importlib import reload\n",
-    "\n",
-    "reload(detectors)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'0.1% AI generated'"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "detectors.detect_ai(text)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "demo",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

app/test/test_models.ipynb

@@ -1,307 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from humanizer_chain import humanize_text"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "text=\"\"\"Biology is the scientific study of life and living organisms, encompassing subdisciplines that examine the structure, \n",
-    "function, growth, origin, and evolution. Molecular biology focuses on interactions among cellular components such as DNA, RNA,\n",
-    " proteins, and other biomolecules. Cellular biology delves into structure and function of cells, units of life. Within cells, \n",
-    " organelles like mitochondria, chloroplasts, and the nucleus illustrate specialization for energy production, photosynthesis, \n",
-    " and genetic regulation. Processes like mitosis and meiosis are essential for growth, \n",
-    "reproduction, and inheritance, while cell signaling enables multicellular coordination.\n",
-    "\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Biology is a science study about life and living things, which include many subfields that look at structure, function, growth, origin, and evolution. Molecular biology is about how parts of cells like DNA, RNA, proteins, and other biomolecules interact with each other. Cellular biology is more about the structure and function of cells because they are the basic units of life. Inside cells, there are organelles such as mitochondria, chloroplasts, and nucleus that show special roles for making energy, doing photosynthesis, and controlling genes. Processes like mitosis and meiosis are very important for growing, reproducing, and passing on traits to next generations. Also cell signaling helps in coordination between many cells in multicellular organisms.\n"
-     ]
-    }
-   ],
-   "source": [
-    "humanized_text =  humanize_text(text)\n",
-    "print(humanized_text)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Requirement already satisfied: transformers in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (4.47.0)\n",
-      "Requirement already satisfied: filelock in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (3.13.1)\n",
-      "Requirement already satisfied: huggingface-hub<1.0,>=0.24.0 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (0.29.3)\n",
-      "Requirement already satisfied: numpy>=1.17 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (1.26.4)\n",
-      "Requirement already satisfied: packaging>=20.0 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (23.2)\n",
-      "Requirement already satisfied: pyyaml>=5.1 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (6.0.2)\n",
-      "Requirement already satisfied: regex!=2019.12.17 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (2024.11.6)\n",
-      "Requirement already satisfied: requests in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (2.32.3)\n",
-      "Requirement already satisfied: tokenizers<0.22,>=0.21 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (0.21.0)\n",
-      "Requirement already satisfied: safetensors>=0.4.1 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (0.4.5)\n",
-      "Requirement already satisfied: tqdm>=4.27 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from transformers) (4.66.5)\n",
-      "Requirement already satisfied: fsspec>=2023.5.0 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from huggingface-hub<1.0,>=0.24.0->transformers) (2024.10.0)\n",
-      "Requirement already satisfied: typing-extensions>=3.7.4.3 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from huggingface-hub<1.0,>=0.24.0->transformers) (4.12.2)\n",
-      "Requirement already satisfied: charset-normalizer<4,>=2 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from requests->transformers) (3.3.2)\n",
-      "Requirement already satisfied: idna<4,>=2.5 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from requests->transformers) (3.7)\n",
-      "Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from requests->transformers) (2.2.3)\n",
-      "Requirement already satisfied: certifi>=2017.4.17 in /opt/miniconda3/envs/demo/lib/python3.10/site-packages (from requests->transformers) (2025.4.26)\n"
-     ]
-    }
-   ],
-   "source": [
-    "!pip install transformers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "    _|    _|  _|    _|    _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|_|_|_|    _|_|      _|_|_|  _|_|_|_|\n",
-      "    _|    _|  _|    _|  _|        _|          _|    _|_|    _|  _|            _|        _|    _|  _|        _|\n",
-      "    _|_|_|_|  _|    _|  _|  _|_|  _|  _|_|    _|    _|  _|  _|  _|  _|_|      _|_|_|    _|_|_|_|  _|        _|_|_|\n",
-      "    _|    _|  _|    _|  _|    _|  _|    _|    _|    _|    _|_|  _|    _|      _|        _|    _|  _|        _|\n",
-      "    _|    _|    _|_|      _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|        _|    _|    _|_|_|  _|_|_|_|\n",
-      "\n",
-      "    A token is already saved on your machine. Run `huggingface-cli whoami` to get more information or `huggingface-cli logout` if you want to log out.\n",
-      "    Setting a new token will erase the existing one.\n",
-      "    To log in, `huggingface_hub` requires a token generated from https://huggingface.co/settings/tokens .\n",
-      "Enter your token (input will not be visible): Traceback (most recent call last):\n",
-      "  File \"/opt/miniconda3/envs/demo/bin/huggingface-cli\", line 8, in <module>\n",
-      "    sys.exit(main())\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/commands/huggingface_cli.py\", line 59, in main\n",
-      "    service.run()\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/commands/user.py\", line 111, in run\n",
-      "    login(\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/utils/_deprecation.py\", line 101, in inner_f\n",
-      "    return f(*args, **kwargs)\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/utils/_deprecation.py\", line 31, in inner_f\n",
-      "    return f(*args, **kwargs)\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/_login.py\", line 130, in login\n",
-      "    interpreter_login(new_session=new_session)\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/utils/_deprecation.py\", line 101, in inner_f\n",
-      "    return f(*args, **kwargs)\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/utils/_deprecation.py\", line 31, in inner_f\n",
-      "    return f(*args, **kwargs)\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/site-packages/huggingface_hub/_login.py\", line 287, in interpreter_login\n",
-      "    token = getpass(\"Enter your token (input will not be visible): \")\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/getpass.py\", line 77, in unix_getpass\n",
-      "    passwd = _raw_input(prompt, stream, input=input)\n",
-      "  File \"/opt/miniconda3/envs/demo/lib/python3.10/getpass.py\", line 146, in _raw_input\n",
-      "    line = input.readline()\n",
-      "KeyboardInterrupt\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "!huggingface-cli login"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_ollama.llms import OllamaLLM\n",
-    "\n",
-    "\n",
-    "load_dotenv()\n",
-    "openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "\n",
-    "\n",
-    "if not openai_api_key:\n",
-    "    raise ValueError(\"OPENAI_API_KEY not found in .env file.\")\n",
-    "\n",
-    "\n",
-    "llm = OllamaLLM(\n",
-    "        model='llama3.2:1b'\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "default_prompt = \"\"\"\n",
-    "Rewrite the following text passage to reflect the writing style of \n",
-    "a non-native English speaker who has achieved a band level 6 in IELTS writing. \n",
-    "This level indicates a competent user of English, but with some inaccuracies, \n",
-    "inappropriate usage, and misunderstandings. \n",
-    "The text should be mostly clear but may contain occasional errors in grammar, vocabulary, and coherence.\n",
-    "\n",
-    "# Text Passage for Rewriting: {input_text}\n",
-    "\n",
-    "Note: Aim for errors that are typical of an IELTS band level 6 writer. \n",
-    "These could include minor grammatical mistakes, slight misuse of vocabulary, \n",
-    "and occasional awkward phrasing. However, the overall meaning of the text \n",
-    "should remain clear and understandable.\n",
-    "\n",
-    "# Word Count: approximately 400#\n",
-    "\n",
-    "In your answer please avoid the text like 'Here is a rewritten version of the ...'\n",
-    "\n",
-    "Humanized Version:\n",
-    "\"\"\"\n",
-    "\n",
-    "\n",
-    "text = \"\"\"In contemporary research, fractal geometry plays an essential role in fields ranging from physics and computer graphics to finance and medicine. For instance, fractal-based algorithms improve image compression, texture synthesis, and pattern recognition. In medicine, fractal analysis assists in characterizing irregular heartbeats or tumor growth patterns. The interplay between fractal geometry and other branches of mathematics, such as measure theory, probability, and number theory, continues to be an active and fruitful area of study.\"\"\"\n",
-    "\n",
-    "\n",
-    "# prompt = ChatPromptTemplate.from_template(template=default_prompt)\n",
-    "\n",
-    "# humanizer_chain = prompt | llm\n",
-    "# response = humanizer_chain.invoke({\"input_text\": text})\n",
-    "# response"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "text = \"\"\"In contemporary research, fractal geometry plays an essential role in fields ranging from physics and computer graphics to finance and medicine. For instance, fractal-based algorithms improve image compression, texture synthesis, and pattern recognition. In medicine, fractal analysis assists in characterizing irregular heartbeats or tumor growth patterns. The interplay between fractal geometry and other branches of mathematics, such as measure theory, probability, and number theory, continues to be an active and fruitful area of study.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# prompt = ChatPromptTemplate.from_template(template=default_prompt)\n",
-    "\n",
-    "# humanizer_chain = prompt | llm\n",
-    "# response = humanizer_chain.invoke({\"input_text\": text})\n",
-    "# response"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### AI Detector Tools API"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import requests\n",
-    "\n",
-    "headers = {\"Authorization\": \"Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiNTI4MzIyNDQtODdjZC00MjgzLWFlNzMtMzVkMGQ5ZmRjNTBkIiwidHlwZSI6ImFwaV90b2tlbiJ9.rjpyEn6SdWpLcIMop2zQPhD8epHQmqBD1p73qN_pA8o\"}\n",
-    "\n",
-    "url = \"https://api.edenai.run/v2/text/ai_detection\"\n",
-    "payload = {\n",
-    "    \"providers\": \"winstonai\",\n",
-    "    \"text\": text,\n",
-    "}\n",
-    "\n",
-    "response = requests.post(url, json=payload, headers=headers)\n",
-    "\n",
-    "result = response.json()\n",
-    "# print(result['winstonai'])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'No more credits': 'Your account does not have enough credits to perform this operation. Please purchase additional credits or add a credit card to receive $10 in free credits.'}"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "result\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "demo",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

main.py

@@ -1,19 +1,156 @@
-from fastapi import FastAPI
-from app.api.endpoints import router
+import os
+from typing import List, Optional
+
+from fastapi import FastAPI, APIRouter, HTTPException
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.responses import RedirectResponse
+from pydantic import BaseModel
+from dotenv import load_dotenv
 
-import os
+# LangChain imports
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+
+
+from scripts.classifier import debert_classifier
+
+
+# ---------------------------
+# Environment setup
+# ---------------------------
+load_dotenv()
+openai_api_key = os.getenv("OPENAI_API_KEY")
+
+if not openai_api_key:
+    raise ValueError("OPENAI_API_KEY not found in .env file.")
+
+
+# ---------------------------
+# Prompt + LangChain model
+# ---------------------------
+DEFAULT_PROMPT = """
+Rewrite the following text in the style of a non-native English speaker with an **IELTS Band 6** writing level. 
 
+The rewritten text should maintain the original meaning clearly, but **include some natural grammatical mistakes, 
+occasional vocabulary misuse, and slightly awkward phrasing** typical of an IELTS Band 6 writer. 
+
+Make sure the tone remains human-like and genuine, with a readable flow, and not too polished or “perfect.” 
+
+This style should be applied **regardless of the content type** (academic, casual, technical, marketing, etc.), 
+so preserve the original tone and context while infusing the non-native characteristics. 
+
+The goal is to **make the text sound human-written (with minor errors)** to reduce the likelihood of 
+AI detection by tools like GPTZero or Originality.ai. 
+
+**Instructions:** Provide **only** the rewritten passage as the output, with no explanations or extra commentary. 
+
+Aim for roughly **400 words** in the rewritten version (adjusting length as needed to stay proportional to the input).
+
+**Text to rewrite:** 
+
+{input_text}
+"""
+
+llm = ChatOpenAI(
+    model="gpt-4o",
+    temperature=0.1,
+    top_p=0.9,
+    frequency_penalty=0.5,
+    presence_penalty=0.3,
+    api_key=openai_api_key,
+)
 
+def humanize_text(text: str) -> str:
+    """Generate a humanized version of input text using LangChain + ChatOpenAI."""
+    prompt = ChatPromptTemplate.from_template(template=DEFAULT_PROMPT)
+    chain = prompt | llm
+    response = chain.invoke({"input_text": text})
+    return response.content
+
+
+# ---------------------------
+# AI Detector (fallback)
+# ---------------------------
+def _detect_ai_fallback(text: str):
+    deberta_result = debert_classifier(text)
+
+    return [
+        {"detector_name": "Deberta Model", "ai_probability": deberta_result},
+        # {"detector_name": "Originality.ai", "ai_probability": 0.65},
+        # {"detector_name": "AI Content Det.", "ai_probability": 0.58},
+    ]
+
+def run_detectors(text: str):
+    try:
+        import app.chains.detectors as detectors
+        return detectors.detect_ai(text)
+    except Exception:
+        return _detect_ai_fallback(text)
+
+
+# ---------------------------
+# FastAPI App
+# ---------------------------
 app = FastAPI(
     title="Text Humanizer",
-    description="Преобразует текст в более естественный человеческий вариант"
+    description="Converts AI-like text into a more human-sounding style using OpenAI API via LangChain",
 )
 
-app.include_router(router)
 app.mount("/static", StaticFiles(directory="app/static", html=True), name="static")
 
+class HumanizeInput(BaseModel):
+    text: str
+
+class DetectInput(BaseModel):
+    text: str
+
+class DetectorResult(BaseModel):
+    detector_name: str
+    ai_probability: float
+
+class DetectionResponse(BaseModel):
+    results: List[DetectorResult]
+
+router = APIRouter()
+
+@router.post("/humanize")
+async def humanize_text_endpoint(input_data: HumanizeInput):
+    try:
+        humanized = humanize_text(input_data.text)
+        return {"original": input_data.text, "humanized": humanized}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/detect", response_model=DetectionResponse)
+async def detect_ai_endpoint(input_data: DetectInput):
+    try:
+        raw = run_detectors(input_data.text)
+        out: List[DetectorResult] = []
+        if isinstance(raw, list):
+            for item in raw:
+                if isinstance(item, dict):
+                    name = item.get("detector_name") or "Detector"
+                    prob = item.get("ai_probability") or 0.0
+                    out.append(DetectorResult(detector_name=name, ai_probability=prob))
+        elif isinstance(raw, dict):
+            for k, v in raw.items():
+                out.append(DetectorResult(detector_name=str(k), ai_probability=float(v)))
+        if not out:
+            out = [DetectorResult(detector_name="Default Detector", ai_probability=0.5)]
+        return DetectionResponse(results=out)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Detection failed: {e}")
+
+@router.get("/get_models")
+async def get_models():
+    return {"models": ["gpt-4o"]}
+
+app.include_router(router)
+
 @app.get("/")
 async def root():
-    return RedirectResponse(url="/static")
+    return RedirectResponse(url="/static")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

scripts/classifier.py

@@ -0,0 +1,4 @@
+
+def debert_classifier(text):
+    # ....
+    return 0.7

scripts/test.py

@@ -0,0 +1,8 @@
+from main import humanize_text
+
+text = """
+Hello my name is Aiken and I am currently working as a data scientist in company
+"""
+
+
+print(humanize_text(text))