docoreai 0.1.0__py3-none-any.whl

docore_ai/__init__.py

@@ -0,0 +1,5 @@
+from .model import intelligence_profiler  # Developer -> from docore_ai import intelligence_profiler
+from .model import normal_prompt
+from .model import normal_prompt_with_intelligence
+
+

docore_ai/demo_model.py

@@ -0,0 +1,77 @@
+import os
+from typing import Optional
+import openai
+import requests
+from dotenv import load_dotenv
+from groq import Groq
+
+load_dotenv()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "groq")  # demo uses 'groq'
+
+
+
+def intelligence_profiler_demo(user_content: str, role: str, reasoning: float = None, 
+                    creativity: float = None, precision: float = None, temperature: float = None, 
+                    model_provider: str = DEFAULT_MODEL,groq_api_key: str = None
+                    ) -> str:
+    system_message = """
+                You are an AI that evaluates a user's request and determines the intelligence profile needed to respond effectively.
+                Given a request analyze the content's (both request and response) complexity and predict the required value between the specified range for the intelligence parameters of a person's role to answer 	    this query. The intelligence parameters to be evaluated are reasoning, creativity and precision.
+            **Return only the intelligence parameter values** in JSON format:",
+            {
+                    "reasoning": 0.1 - 1.0,  // How logically structured and in-depth the response should be. 0.1 = simple, 1.0 = deep and complex.
+                    "creativity": 0.1 - 1.0, // How much imaginative variation should be introduced. 0.1 = factual, 1.0 = highly creative.
+                    "precision": 0.1 - 1.0,  // How specific or general the response should be. 0.1 = broad, 1.0 = highly detailed.
+                    "temperature": 0.1 - 1.0, // Derived from above values
+            }
+            ### **Rules:**                    
+            The temperature should be automatically calculated dynamically based on the reasoning, creativity, and precision values.
+            Do not provide explanations, only return the JSON output.
+    """
+    user_message = """
+            Analyze the request: {user_content} and understand the complexity of this request and intelligence required for the best possible response.
+            Predict the right value between the specified range required for the intelligence parameters of a person's role {role} to answer this query.
+
+            Return them in the structured JSON format:
+            {
+                "reasoning": 0.1 - 1.0,
+                "creativity": 0.1 - 1.0,
+                "precision": 0.1 - 1.0,
+                "temperature": 0.1 - 1.0
+            }
+            **Return only the JSON response and no additional text.**
+                """
+    messages = [
+        {"role": "system", "content": "\n".join(system_message)} , #if not manual_mode else None,
+        {"role": "user", "content": f'User Input: {user_message}\nRole: Intelligence Evaluator'}
+                ]
+    messages = [msg for msg in messages if msg]  # Remove None values
+
+    client = Groq(api_key=groq_api_key) 
+    chat_completion = client.chat.completions.create(
+            messages=messages,
+            model="gemma2-9b-it",
+            temperature=0.3 # if temperature is not None else (1.0 - reasoning if manual_mode else 0.7)            
+        )       
+    response_text = chat_completion.choices[0].message.content  # Extract response
+    return response_text
+
+# Custom OpenAPI schema to remove validation errors
+'''def custom_openapi():
+    if app.openapi_schema:
+        return app.openapi_schema
+    openapi_schema = get_openapi(
+        title=app.title,
+        version=app.version,
+        description=app.description,
+        routes=app.routes,
+    )
+    # Remove validation error schemas
+    openapi_schema["components"]["schemas"].pop("HTTPValidationError", None)
+    openapi_schema["components"]["schemas"].pop("ValidationError", None)
+    app.openapi_schema = openapi_schema
+    return app.openapi_schema
+# Assign the custom OpenAPI schema
+app.openapi = custom_openapi'''

docore_ai/model.py

@@ -0,0 +1,156 @@
+import os
+from typing import Optional
+import openai
+import requests
+from dotenv import load_dotenv
+from groq import Groq
+
+load_dotenv()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "groq")  # Default to groq
+MODEL = os.getenv("MODEL", "gemma2-9b-it")  # Default to gemma2-9b-it
+
+
+def intelligence_profiler(user_content: str, role: str, model_provider: str = DEFAULT_MODEL, model_name: str = MODEL) -> str:
+    
+    #if manual_mode: # TODO -- manual_mode option can generate efficient prompts based on intelligence params given with input user_content & role 
+    #    reasoning = max(0.1, min(1.0, reasoning)) if reasoning is not None else 0.5
+    #    creativity = max(0.1, min(1.0, creativity)) if creativity is not None else 0.5
+    #    precision = max(0.1, min(1.0, precision)) if precision is not None else 0.5
+
+    system_message = """
+    You are an AI Intelligence Profiler. Your task is to analyze a user's request and determine the optimal intelligence parameters needed for an effective response. The parameters to be evaluated are:
+
+    - **reasoning** (0.1 to 1.0): The level of logical depth required.
+    - **creativity** (0.1 to 1.0): The degree of imaginative variation required.
+    - **precision** (0.1 to 1.0): The specificity level required.
+    - **temperature** (0.1 to 1.0): A value derived from the above parameters that influences overall output variability.
+
+    **Instructions:**
+    1. Analyze the user's request and consider the specified role.
+    2. Adjust the intelligence parameters based on the query's complexity and the typical expertise required for that role.
+    3. **Return ONLY a JSON object** in the exact format below, with no extra text or explanation:
+
+    {
+        "reasoning": <value>,
+        "creativity": <value>,
+        "precision": <value>,
+        "temperature": <value>
+    }
+    """
+    user_message = f"""
+    User Request: "{user_content}"
+    Role: "{role}"
+   
+
+    Please evaluate the above information and return the intelligence parameters in the specified JSON format.
+    """
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_message}
+    ]
+
+    # Choose model provider
+    if model_provider == "openai":
+        openai.api_key = OPENAI_API_KEY
+        response = openai.Client().chat.completions.create(
+            model=model_name,
+            messages=messages,
+            temperature=0.4
+        )
+        return response.choices[0].message.content
+    elif model_provider == "groq":
+        client = Groq(api_key=GROQ_API_KEY) 
+        chat_completion = client.chat.completions.create(
+            messages=messages,
+            model=model_name,
+            temperature=0.2 #temperature if temperature is not None else (1.0 - reasoning if manual_mode else 0.7)            
+        )       
+        response_text = chat_completion.choices[0].message.content  # Extract response
+        return response_text
+    
+def normal_prompt(user_content: str, role: str, model_provider: str = DEFAULT_MODEL, model_name: str = MODEL):
+    """
+    Sends a normal prompt to the selected LLM (OpenAI or Groq) without intelligence parameters.
+    """
+    system_message = f"""
+    You are a {role}. Respond to user queries based on your role expertise.
+    Provide a well-structured response based on best practices in your field.
+    """
+
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_content}
+    ]
+
+    response = call_llm_without_temp(model_provider, model_name, messages)
+    return response
+
+def normal_prompt_with_intelligence(user_content: str, role: str, model_provider: str = DEFAULT_MODEL, model_name: str = MODEL, reasoning: float = 0.5, creativity: float = 0.5, precision: float = 0.5, temperature: float = 0.5):
+    """
+    Sends a prompt to the selected LLM with intelligence parameters.
+    """
+    system_message = f"""
+    You are a {role}. Respond to user queries based on your role expertise.
+    Provide a well-structured response based on best practices in your field.
+    Adjust the response style dynamically based on intelligence parameters:
+    - Reasoning: {reasoning} (0.1 = simple, 1.0 = deep and structured)
+    - Creativity: {creativity} (0.1 = factual, 1.0 = imaginative)
+    - Precision: {precision} (0.1 = broad, 1.0 = highly detailed)
+    """
+
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": user_content}
+    ]
+
+    response = call_llm(model_provider, model_name, messages, temperature)
+    return response
+
+def call_llm(model_provider: str, model_name: str, messages: list, temperature: float):
+    """
+    Handles communication with OpenAI or Groq models.
+    """
+    if model_provider == "openai":
+        response = openai.Client().chat.completions.create(
+            model=model_name,
+            messages=messages,
+            temperature=temperature
+        )
+        return response.choices[0].message.content
+
+    elif model_provider == "groq":
+        # Implement Groq API call (replace with actual implementation)
+        client = Groq(api_key=GROQ_API_KEY) 
+        chat_completion = client.chat.completions.create(
+            messages=messages,
+            model=model_name,
+            temperature=temperature #temperature if temperature is not None else (1.0 - reasoning if manual_mode else 0.7)            
+        )
+        return f"Simulated Groq response for model: {model_name}, Temp: {temperature}"
+
+    else:
+        raise ValueError("Invalid model provider. Choose 'openai' or 'groq'.")
+
+def call_llm_without_temp(model_provider: str, model_name: str, messages: list):
+    """
+    Calls OpenAI or Groq API without specifying temperature, so it defaults to the model's own value.
+    """
+    if model_provider == "openai":
+        response = openai.Client().chat.completions.create(
+            model=model_name,
+            messages=messages
+        )
+        return response.choices[0].message.content
+
+    elif model_provider == "groq":
+        client = Groq(api_key=GROQ_API_KEY) 
+        chat_completion = client.chat.completions.create(
+            messages=messages,
+            model=model_name,
+        )
+        return f"Simulated Groq response for model: {model_name} (Using default LLM temperature)"
+
+    else:
+        raise ValueError("Invalid model provider. Choose 'openai' or 'groq'.")

docoreai-0.1.0.dist-info/LICENSE.md

@@ -0,0 +1,22 @@
+# DoCoreAI License  
+
+## 1. License Grant  
+This software is open-source and provided under the **MIT License**, with additional restrictions for SaaS and multi-agent implementations.  
+
+## 2. Permitted Uses  
+- Free to **use, modify, and distribute** for **personal, research, and non-commercial** purposes.  
+- Can be **integrated into private applications** or internal projects.  
+
+## 3. Restrictions  
+- **No SaaS Deployment** – This software **cannot** be offered as a hosted or cloud-based service without explicit permission.  
+- **No Multi-Agent Orchestration** – You **may not** modify or extend the software for multi-agent systems.  
+- **Commercial Use Requires Permission** – Enterprises or businesses must obtain a **commercial license** before monetizing this software.  
+
+## 4. Contributions  
+Contributions are welcomed! Any submitted code is licensed under the same terms as this project.  
+
+## 5. Liability Disclaimer  
+This software is provided **"as is"** without warranties of any kind. The authors are **not liable** for any damages resulting from its use.  
+
+## 6. Commercial Licensing  
+For enterprise or SaaS licensing, contact **sajijohnmiranda@gmail.com**.  

docoreai-0.1.0.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.2
+Name: docoreai
+Version: 0.1.0
+Summary: DoCoreAI is an intelligence profiler that optimizes prompts
+Home-page: https://github.com/SajiJohnMiranda/DoCoreAI
+Author: Saji John
+Author-email: sajijohnmiranda@gmail.com
+Project-URL: Documentation, https://your-docs-url.com
+Project-URL: Blog Post, https://mobilights.medium.com/intelligent-prompt-optimization-bac89b64fa84
+Project-URL: Source Code, https://github.com/SajiJohnMiranda/DoCoreAI
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: uvicorn
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv
+Requires-Dist: openai
+Requires-Dist: langchain
+Requires-Dist: groq
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🌟 DoCoreAI – The Future of Smart AI Interactions  
+
+**🚀 Optimize LLM Responses | 🛠️ Fine-Tune AI Intelligence | ⚡ Supercharge Prompting**  
+
+---
+
+## 🔥 What is DoCoreAI?  
+DoCoreAI is an AI **intelligence profiler that optimizes prompts dynamically** based on predefined intelligence parameters. Instead of relying on generic LLM prompts, DoCoreAI customizes intelligence properties (such as reasoning, creativity, and precision) to ensure AI agents generate responses that perfectly align with their roles.
+
+Its an **open-source powerhouse** designed to make **Large Language Models (LLMs) smarter, sharper, and more efficient**. It acts as a **plug-and-play optimizer** that dynamically enhances AI reasoning, problem-solving, and decision-making, giving developers total control over AI intelligence. 
+
+Whether you're building an AI agent, chatbot, a virtual assistant, or a SaaS application, **DoCoreAI fine-tunes AI prompts in real time**, ensuring **clear, precise, and highly contextual responses**.  
+
+---
+
+## 🌍 Why DoCoreAI?  
+### ✅ **Key Benefits**
+- **🧠 Smarter AI** – Enhances reasoning, problem-solving, and adaptability.
+- **⚡ Best Responses** – Intelligent prompts mean more accurate answers.
+- **🔧 Full Control** – Developers can fine-tune intelligence parameters like depth, creativity, and accuracy.
+- **🔌 Easy API Integration** – Works seamlessly with OpenAI, Cohere, Mistral, and other LLMs.
+- **🛠️ Open-Source & Extensible** – Customize it for your specific use case.
+
+  🚨Lets see some Problems:
+
+  - Generic LLM prompts don’t tell AI agents how smart to be for a task.
+
+  - LLMs respond the same way to different tasks, often lacking role-specific intelligence.
+
+  - A customer support AI should be empathetic and clear, while a data analyst AI should be logical and precise.
+
+  - Generic prompts fail to define the intelligence level needed to perform a task efficiently when some tasks need high reasoning, low creativity, while others need high creativity, low precision..
+
+  The Solution:
+
+  DoCoreAI solves this by intelligently adjusting skill parameters based on context, so LLMs generate perfect responses for each role, ensuring:
+  - Better response accuracy
+  - Improved AI agent adaptability
+  - Optimized decision-making and creativity when needed
+
+---
+
+## 💡 How Does It Work?  
+
+DoCoreAI follows a structured process to enhance AI prompts:
+
+1️⃣ AI Role Detection – Identifies the AI agent’s role and task.  
+2️⃣ Intelligence Mapping – Assigns reasoning, creativity, precision, and temperature values.  
+3️⃣ Prompt Optimization – Fine-tunes the input prompt using optimized intelligence properties.  
+4️⃣ LLM Execution – Sends the enhanced prompt to OpenAI, Groq, or other supported models.
+
+💡 Example:  
+**Before** DoCoreAI: "Summarize this report."  
+**After** DoCoreAI: "Summarize this report with high precision (0.9), low creativity (0.2), and deep reasoning (0.8)."
+
+### **🔗 Step-by-Step Workflow:**
+1️⃣ **User Query →** A user submits a question/query to your application.  
+2️⃣ **DoCoreAI Enhances Prompt →** The system analyzes the query or prompt and generates an optimized prompt with **dynamic intelligence parameters**. The required intelligence range  for each these parameters (like **Reasoning** - Determines logical depth, **Creativity** - Adjusts randomness , **Precision** - Controls specificity)  are inferred from the query automatically. 
+
+3️⃣ **Send to LLM →** The refined prompt is sent to your preferred LLM (OpenAI, Anthropic, Cohere, etc.).  
+4️⃣ **LLM Response →** The model returns a highly optimized answer.  
+5️⃣ **Final Output →** Your application displays the AI’s enhanced response to the user.  
+
+👉 **End Result?** More accurate, contextually rich, and intelligent AI responses that **feel human-like and insightful**.  
+
+---
+
+## 💡 How DoCoreAI Helps AI Agents
+
+DoCoreAI ensures that AI agents perform at their best by customizing intelligence settings per task. Here’s how:  
+
+📞 Support Agent AI → Needs high empathy, clarity, and logical reasoning.  
+📊 Data Analyst AI → Requires high precision and deep analytical reasoning.  
+🎨 Creative Writing AI → Boosts creativity for idea generation and storytelling.  
+
+This adaptive approach ensures that LLMs deliver role-specific, optimized responses every time.
+
+---
+
+## 🚀 Use Cases
+DoCoreAI is highly versatile and can be integrated across various domains:
+
+🔹 Customer Support AI: Ensures friendly, concise, and empathetic interactions.  
+🔹 Business Analytics AI: Generates precise reports with accurate insights.  
+🔹 Medical AI Assistants: Maintains high reasoning while reducing creativity for factual correctness.  
+🔹 Content Creation AI: Enhances creativity while keeping precision at a balanced level.  
+🔹 Legal & Compliance AI: Ensures responses are strictly factual and highly precise.  
+
+### 🏢 **For Businesses & Startups:**
+- **🤖 AI Agents, Chatbots & Virtual Assistants** – Make AI interactions **more natural and helpful**.
+- **📞 AI Customer Support** – Improve support accuracy, reducing agent workload.
+- **📊 Data & Market Analysis** – Extract **meaningful insights from unstructured data**.
+- **🎨 Creative AI** –  Enhances storytelling, content generation, and brainstorming.
+
+### 🛠️ **For Developers & Engineers:**
+- **⚙️ Fine-Tuning Custom LLMs** – Boost reasoning, logic, and adaptability.
+- **📝 AI-Powered Content Generation** – Enhance blogs, marketing copy, and technical writing.
+- **🧪 Research & Experimentation** – Test and build **next-gen AI applications**.  
+
+### 🍒 **Generalized solution for All**
+- **⚙️ Easily Works across all domains and user roles, allowing fine-tuning for different applications
+  
+---
+
+## 🎯 Getting Started
+### **📌 Installation**
+1️⃣ Clone the repo:
+```bash
+ git clone https://github.com/SajiJohnMiranda/DoCoreAI.git
+```
+2️⃣ Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+3️⃣ Run DoCoreAI:
+```bash
+uvicorn api.main:app
+```
+4️⃣ Start using the API:
+```bash
+Browser POST "http://127.0.0.1:8000/docs" Select /intelligence-profiler-demo 
+```
+
+🎉 **You're all set to build smarter AI applications!**  
+
+---
+
+## 🔗 Integrations & Compatibility
+DoCoreAI is designed to work seamlessly with major AI platforms:
+- Works with **OpenAI GPT, Claude, LLaMA, Falcon, Cohere, and more.**
+- Supports **LangChain, FastAPI, Flask, and Django.**
+- Easy to extend via **plugin-based architecture.**
+
+---
+
+## 📈 Why Developers Should Use DoCoreAI
+
+🔹 Smarter AI, Better Results  
+-Ensures AI models understand the intelligence scope required for each task.  
+-Enhances prompt efficiency, reducing trial and error in prompt engineering.
+
+🔹 Saves Time & Effort  
+-No need for manual prompt tuning—DoCoreAI does it for you.  
+-Works out of the box with OpenAI and Groq models.
+
+🔹 Ideal for SaaS & AI-driven Applications  
+-Perfect for chatbots, AI assistants, automation, and enterprise AI solutions.  
+-DoCoreAI transforms AI interactions by making prompts truly intelligent.
+
+---
+
+## 🌟 Join the Community:  
+Let’s build the future of AI-powered intelligence tuning together! 🚀  
+🤝 **Contribute:** Open issues, create pull requests, and help improve DoCoreAI!  
+📢 **Discuss & Collaborate:** Join our **Discord & GitHub Discussions**.  
+🌟 **Star the Repo!** If you find this useful, don’t forget to star ⭐ it on GitHub!  
+
+👉 [GitHub Repo](https://github.com/SajiJohnMiranda/DoCoreAI) | [Docs (Coming Soon)]  
+
+
+## Recommended LLMs for Intelligence Optimization
+DoCoreAI is designed to refine and optimize user prompts by dynamically adjusting intelligence parameters such as reasoning, creativity, and precision. To achieve the best results, we recommend using ChatGPT (GPT-4-turbo) for this task.
+While DoCoreAI is compatible with other LLMs (e.g., LLaMA 3, Claude etc), results may vary depending on the model’s capabilities. Developers are encouraged to experiment and contribute insights on different LLM integrations.
+
+**Future Support for Fine-Tuned Models:**  
+We recognize the growing demand for fine-tuned open-source models tailored for specific applications. In future updates, we aim to explore Integration with fine-tuned LLaMA/Custom GPT models, Support for locally deployed models (via Ollama, vLLM, etc.) & Customization of intelligence parameters based on domain-specific data.
+
+Our vision is to make DoCoreAI adaptable to both proprietary and open-source AI models, ensuring flexibility for all developers. Contributions and suggestions are welcome!
+
+---
+
+## ⚖️ License
+Licensed under [MIT License](./LICENSE.md). Use freely, contribute, and enhance AI for everyone!    
+
+---
+
+💡 **Let’s revolutionize AI prompt optimization together!** 🚀
+

docoreai-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+docore_ai/__init__.py,sha256=u4ZRml0BzzjFaVNELCUpLYPk2yvhsyrDTZoPWsNVa0E,192
+docore_ai/demo_model.py,sha256=XTcjR6Jr8OCjrRQbjuxgbyqZ09BIm-E7xrC2lft8PYQ,3991
+docore_ai/model.py,sha256=HW5zp_zpVDHdZg_pdxBPELNFlyohSYPV2lBTZQ4C6-A,6651
+docoreai-0.1.0.dist-info/LICENSE.md,sha256=lVjVcIFTNTiTngr17Q4652qM-dCepIsQD46kr_Hl1z8,1215
+docoreai-0.1.0.dist-info/METADATA,sha256=SDLXXKvcmOF7dMwPQgOomkv0yZ3VHRn5j3HuYTrHo14,10173
+docoreai-0.1.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+docoreai-0.1.0.dist-info/top_level.txt,sha256=J6RKFznnZg8wXoJraMp14Xl8vamttisBUkXJmMcmQDQ,10
+docoreai-0.1.0.dist-info/RECORD,,

docoreai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

docoreai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+docore_ai