WordPress content agent

.env.example

@@ -0,0 +1,7 @@
+# OpenWeather API Key
+OPENWEATHER_API_KEY=your_api_key_here
+
+# WordPress Configuration (optional)
+WP_SITE_URL=https://your-wordpress-site.com
+WP_USERNAME=your_username
+WP_APP_PASSWORD=your_app_password 

.gitignore

@@ -0,0 +1 @@
+instructions.md

agent.json

@@ -1,54 +0,0 @@
-{
-  "tools": [
-    "get_weather",
-    "quick_research",
-    "image_generation_tool",
-    "final_answer"
-  ],
-  "model": {
-    "class": "HfApiModel",
-    "data": {
-      "max_tokens": 2096,
-      "temperature": 0.5,
-      "last_input_token_count": null,
-      "last_output_token_count": null,
-      "model_id": "Qwen/Qwen2.5-Coder-32B-Instruct",
-      "custom_role_conversions": null
-    }
-  },
-  "prompt_templates": {
-    "system_prompt": "You are an expert AI Travel Planner who helps users create personalized travel itineraries. You have deep knowledge of destinations worldwide and can provide detailed recommendations based on weather, local attractions, and activities.\n\nTo help plan trips, you have access to these tools:\n- get_weather: Get weather forecasts for destinations\n- quick_research: Research destinations, attractions, and activities\n- image_generation_tool: Generate visual previews of destinations\n- final_answer: Provide the final travel plan\n\nTo solve each travel planning task, proceed in a series of 'Thought:', 'Code:', and 'Observation:' sequences.\n\nAt each step:\n1. In 'Thought:', explain your reasoning about what travel information to gather next\n2. In 'Code:', write Python code to use the available tools\n3. End each code block with '<end_code>'\n4. Use print() to save important travel details\n5. Review the 'Observation:' output before proceeding\n6. Finally, provide a complete travel plan using final_answer\n\nExample:\nTask: \"Plan a 3-day trip to Paris in June\"\n\nThought: First, I'll check the weather forecast for Paris in June to help plan appropriate activities.\nCode:\n```py\nweather = get_weather(city=\"Paris\", month=\"June\")\nprint(weather)\n```<end_code>\nObservation: \"Mild temperatures 18-25°C (65-77°F), occasional light rain\"\n\nThought: Now I'll research key attractions and activities suitable for the weather.\nCode:\n```py\nactivities = quick_research(query=\"top attractions Paris summer activities\")\nprint(activities)\n```<end_code>\nObservation: \"1. Eiffel Tower, best in early morning or sunset\n2. Louvre Museum - perfect for occasional rainy periods\n3. Seine River cruises - pleasant in mild weather\n4. Luxembourg Gardens - beautiful in June\"\n\nThought: Let me generate a preview image of Paris in summer.\nCode:\n```py\nimage = image_generation_tool(\"Paris cityscape in June, with Eiffel Tower and blooming gardens\")\nfinal_answer({\"itinerary\": \"Day 1: Morning - Eiffel Tower...\", \"weather\": weather, \"preview\": image})\n```<end_code>\n\nHere are the rules you should follow:\n1. Always provide 'Thought:', 'Code:', and proper code block endings\n2. Research weather before suggesting outdoor activities\n3. Consider seasonal events and local customs\n4. Provide practical travel tips based on weather and local conditions\n5. Generate relevant preview images of recommended locations\n6. Include both indoor and outdoor activity options\n7. Format the final travel plan clearly with daily breakdowns\n\nThe tools available to you are:\n{%- for tool in tools.values() %}\n- {{ tool.name }}: {{ tool.description }}\n    Takes inputs: {{tool.inputs}}\n    Returns an output of type: {{tool.output_type}}\n{%- endfor %}\n\nYou can use these Python modules: {{authorized_imports}}\n\nNow begin planning amazing trips for users!",
-    "planning": {
-      "initial_facts": "Below I will analyze the travel planning task.\n\n### 1. Facts given in the task\nList specific details provided (destination, dates, preferences, etc.)\n\n### 2. Facts to look up\n- Weather conditions\n- Local attractions and activities\n- Seasonal events\n- Travel logistics\n\n### 3. Facts to derive\n- Suitable activities based on weather\n- Daily itinerary structure\n- Backup plans for weather changes\n- Visual previews of key locations",
-      "initial_plan": "You are an expert travel planner creating detailed itineraries.\n\nDevelop a step-by-step plan for the given travel task using available tools.\nFocus on gathering essential travel information and creating a comprehensive itinerary.\n\nTask:\n```\n{{task}}\n```\n\nAvailable tools:\n{%- for tool in tools.values() %}\n- {{ tool.name }}: {{ tool.description }}\n    Takes inputs: {{tool.inputs}}\n    Returns an output of type: {{tool.output_type}}\n{%- endfor %}\n\nKnown facts:\n```\n{{answer_facts}}\n```\n\nWrite your travel planning steps below, ending with '<end_plan>'",
-      "update_facts_pre_messages": "You are a world expert at gathering known and unknown facts based on a conversation.\nBelow you will find a task, and a history of attempts made to solve the task. You will have to produce a list of these:\n### 1. Facts given in the task\n### 2. Facts that we have learned\n### 3. Facts still to look up\n### 4. Facts still to derive\nFind the task and history below:",
-      "update_facts_post_messages": "Earlier we've built a list of facts.\nBut since in your previous steps you may have learned useful new facts or invalidated some false ones.\nPlease update your list of facts based on the previous history, and provide these headings:\n### 1. Facts given in the task\n### 2. Facts that we have learned\n### 3. Facts still to look up\n### 4. Facts still to derive\n\nNow write your new list of facts below.",
-      "update_plan_pre_messages": "You are a world expert at making efficient plans to solve any task using a set of carefully crafted tools.\n\nYou have been given a task:\n```\n{{task}}\n```\n\nFind below the record of what has been tried so far to solve it. Then you will be asked to make an updated plan to solve the task.\nIf the previous tries so far have met some success, you can make an updated plan based on these actions.\nIf you are stalled, you can make a completely new plan starting from scratch.",
-      "update_plan_post_messages": "Continue planning this trip:\n```\n{{task}}\n```\n\nAvailable tools:\n{%- for tool in tools.values() %}\n- {{ tool.name }}: {{ tool.description }}\n    Takes inputs: {{tool.inputs}}\n    Returns an output of type: {{tool.output_type}}\n{%- endfor %}\n\nUpdated travel facts:\n```\n{{facts_update}}\n```\n\nDevelop next steps in the travel plan. You have {remaining_steps} steps remaining.\nFocus on completing essential planning elements first.\nEnd with '<end_plan>'\n\nWrite your updated travel plan below."
-    },
-    "managed_agent": {
-      "task": "You're a helpful agent named '{{name}}'.\nYou have been submitted this task by your manager.\n---\nTask:\n{{task}}\n---\nYou're helping your manager solve a wider task: so make sure to not provide a one-line answer, but give as much information as possible to give them a clear understanding of the answer.\n\nYour final_answer WILL HAVE to contain these parts:\n### 1. Task outcome (short version):\n### 2. Task outcome (extremely detailed version):\n### 3. Additional context (if relevant):\n\nPut all these in your final_answer tool, everything that you do not pass as an argument to final_answer will be lost.\nAnd even if your task resolution is not successful, please return as much context as possible, so that your manager can act upon this feedback.",
-      "report": "Here is the final answer from your managed agent '{{name}}':\n{{final_answer}}"
-    }
-  },
-  "max_steps": 8,
-  "verbosity_level": 1,
-  "grammar": null,
-  "planning_interval": null,
-  "name": null,
-  "description": null,
-  "authorized_imports": [
-    "unicodedata",
-    "stat",
-    "datetime",
-    "random",
-    "pandas",
-    "itertools",
-    "math",
-    "statistics",
-    "queue",
-    "time",
-    "collections",
-    "re"
-  ]
-}

app.py

@@ -1,12 +1,26 @@
+import os
+from dotenv import load_dotenv
 from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 import datetime
 import requests
 import pytz
 import yaml
 from tools.final_answer import FinalAnswerTool
+from tools.wordpress_auth import WordPressAuthTool
+from tools.wordpress_post import WordPressPostTool
+from tools.blog_generator import BlogGeneratorTool
+from tools.visit_webpage import VisitWebpageTool
+from tools.web_search import DuckDuckGoSearchTool
 
 from Gradio_UI import GradioUI
 
+# Load environment variables
+load_dotenv()
+
+# Verify required environment variables
+if not os.getenv("OPENWEATHER_API_KEY"):
+    print("Warning: OPENWEATHER_API_KEY not set. Weather functionality will be limited.")
+
 
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
@@ -99,6 +113,8 @@ def get_weather(city: str) -> str:
 
 
 final_answer = FinalAnswerTool()
+visit_webpage = VisitWebpageTool()
+web_search = DuckDuckGoSearchTool()
 
 # If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
 # model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud'
@@ -120,10 +136,25 @@ image_generation_tool = load_tool(
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
 
+# Initialize WordPress tools
+wordpress_auth = WordPressAuthTool()
+wordpress_post = WordPressPostTool(auth_tool=wordpress_auth)
+blog_generator = BlogGeneratorTool(model=model)
+
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, get_current_time_in_timezone, image_generation_tool,
-           quick_research, get_weather],  # added get_weather tool
+    tools=[
+        final_answer,
+        get_current_time_in_timezone,
+        image_generation_tool,
+        quick_research,
+        get_weather,
+        wordpress_auth,
+        wordpress_post,
+        blog_generator,
+        visit_webpage,
+        web_search
+    ],
     max_steps=6,
     verbosity_level=1,
     grammar=None,
@@ -133,5 +164,27 @@ agent = CodeAgent(
     prompt_templates=prompt_templates
 )
 
+# Update system prompt to include WordPress capabilities
+prompt_templates["system_prompt"] += """
+
+You are also capable of managing a WordPress blog through the following tools:
+- wordpress_auth: Manages WordPress authentication (site URL, username, password)
+- wordpress_post: Publishes posts to WordPress
+- blog_generator: Generates AI-written blog posts
+
+Before using WordPress features, you must ensure credentials are set using wordpress_auth.
+Always check credentials before attempting to post content.
+
+Example WordPress workflow:
+1. Set credentials (first time only)
+2. Generate blog content
+3. Publish to WordPress
+
+Remember to:
+- Validate WordPress credentials before posting
+- Generate high-quality, relevant content
+- Handle errors gracefully
+- Provide clear status updates to the user
+"""
 
 GradioUI(agent).launch()

requirements.txt

@@ -1,6 +1,9 @@
-markdownify
-smolagents
-requests
-duckduckgo_search
-pandas
-requests
+markdownify>=0.7.0
+smolagents>=0.1.0
+requests>=2.31.0
+duckduckgo_search>=4.1.0
+pandas>=2.0.0
+pytz>=2024.1
+pyyaml>=6.0.1
+gradio>=5.15.0
+python-dotenv>=1.0.0

tools/blog_generator.py

@@ -0,0 +1,59 @@
+from typing import Dict
+from smolagents.tools import Tool
+
+
+class BlogGeneratorTool(Tool):
+    name = "blog_generator"
+    description = "Generates an AI-written blog post on a given topic"
+    inputs = {
+        'topic': {'type': 'string', 'description': 'The topic to write about'},
+        'style': {'type': 'string', 'description': 'Writing style: casual, professional, or technical. Default is professional'}
+    }
+    output_type = "dict"
+
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+
+    def forward(self, topic: str, style: str = "professional") -> Dict:
+        """Generates a blog post using AI
+        Args:
+            topic: The topic to write about
+            style: Writing style (casual, professional, technical)
+        Returns:
+            Dict containing the generated title and content
+        """
+        # Create prompt based on style
+        style_prompts = {
+            "casual": "Write a friendly and conversational blog post",
+            "professional": "Write a well-researched and authoritative blog post",
+            "technical": "Write a detailed technical blog post with examples"
+        }
+
+        base_prompt = style_prompts.get(style, style_prompts["professional"])
+        prompt = f"{base_prompt} about {topic}. Include an engaging title, introduction, main points with subheadings, and a conclusion. Format the content in HTML."
+
+        try:
+            # Generate content using the model
+            response = self.model.generate(prompt)
+
+            # Extract title and content (assuming model returns HTML-formatted text)
+            content = response.text if response else ""
+
+            # Basic content validation
+            if not content or len(content) < 100:
+                return {
+                    "status": "error",
+                    "message": "Generated content too short or empty"
+                }
+
+            return {
+                "status": "success",
+                "content": content
+            }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "message": f"Error generating blog post: {str(e)}"
+            }

tools/wordpress_auth.py

@@ -0,0 +1,45 @@
+from typing import Dict, Optional
+from smolagents.tools import Tool
+
+
+class WordPressAuthTool(Tool):
+    name = "wordpress_auth"
+    description = "Manages WordPress authentication credentials"
+    inputs = {
+        'action': {'type': 'string', 'description': 'Action to perform: set_credentials or get_credentials'},
+        'credentials': {
+            'type': 'dict',
+            'description': 'WordPress credentials dictionary containing site_url, username, and app_password'
+        }
+    }
+    output_type = "dict"
+
+    def __init__(self):
+        super().__init__()
+        self._credentials: Optional[Dict] = None
+
+    def forward(self, action: str, credentials: Optional[Dict] = None) -> Dict:
+        """Manages WordPress credentials
+        Args:
+            action: Either 'set_credentials' or 'get_credentials'
+            credentials: Dict containing site_url, username, and app_password (only for set_credentials)
+        Returns:
+            Dict containing the current credentials or status message
+        """
+        if action == "set_credentials":
+            if not credentials:
+                return {"error": "Credentials required for set_credentials action"}
+
+            required_fields = ["site_url", "username", "app_password"]
+            if not all(field in credentials for field in required_fields):
+                return {"error": f"Missing required fields. Need: {required_fields}"}
+
+            self._credentials = credentials
+            return {"status": "Credentials stored successfully"}
+
+        elif action == "get_credentials":
+            if not self._credentials:
+                return {"error": "No credentials set. Please set credentials first."}
+            return self._credentials
+
+        return {"error": "Invalid action. Use 'set_credentials' or 'get_credentials'"}

tools/wordpress_post.py

@@ -0,0 +1,64 @@
+import requests
+from requests.auth import HTTPBasicAuth
+from typing import Dict, Optional
+from smolagents.tools import Tool
+
+
+class WordPressPostTool(Tool):
+    name = "wordpress_post"
+    description = "Publishes a blog post to WordPress using the REST API"
+    inputs = {
+        'title': {'type': 'string', 'description': 'The title of the blog post'},
+        'content': {'type': 'string', 'description': 'The content of the blog post in HTML format'},
+        'status': {'type': 'string', 'description': 'Post status: publish, draft, or private. Default is publish'}
+    }
+    output_type = "dict"
+
+    def __init__(self, auth_tool):
+        super().__init__()
+        self.auth_tool = auth_tool
+
+    def forward(self, title: str, content: str, status: str = "publish") -> Dict:
+        """Publishes a post to WordPress
+        Args:
+            title: The title of the blog post
+            content: The content in HTML format
+            status: Post status (publish, draft, private)
+        Returns:
+            Dict containing status and post URL or error message
+        """
+        # Get WordPress credentials
+        creds = self.auth_tool.forward(action="get_credentials")
+        if "error" in creds:
+            return creds
+
+        url = f"{creds['site_url']}/wp-json/wp/v2/posts"
+
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        data = {
+            "title": title,
+            "content": content,
+            "status": status
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=data,
+                headers=headers,
+                auth=HTTPBasicAuth(creds['username'], creds['app_password'])
+            )
+            response.raise_for_status()
+            return {
+                "status": "success",
+                "message": "Post published successfully!",
+                "url": response.json().get('link')
+            }
+        except requests.exceptions.RequestException as e:
+            return {
+                "status": "error",
+                "message": f"Error publishing post: {str(e)}"
+            }