Upload folder using huggingface_hub

.env.example

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=
+FIRECRAWL_API_KEY=

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,4 @@
+project_snapshot_no_images.json
+.venv
+.env
+__pycache__

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,3 @@
+{
+  "tests/integration_test.py": true
+}

.pytest_cache/v/cache/nodeids

@@ -0,0 +1 @@
+[]

.pytest_cache/v/cache/stepwise

@@ -0,0 +1 @@
+[]

README.md

@@ -1,12 +1,108 @@
 ---
-title: Openai Swarm Firecrawl
-emoji: 📚
-colorFrom: yellow
-colorTo: pink
+title: openai_swarm_firecrawl
+app_file: user_interface.py
 sdk: gradio
 sdk_version: 5.1.0
-app_file: app.py
-pinned: false
 ---
+# Swarm Firecrawl Marketing Agent
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+A multi-agent system using OpenAI's Swarm for AI-powered content analysis and generation, integrated with Firecrawl for web scraping. This project features a Gradio-based user interface for easy interaction and configuration of the agent swarm.
+
+## Features
+
+- Web scraping using Firecrawl API
+- Configurable multi-agent system for content analysis and generation
+- Interactive Gradio-based graphical user interface
+- Real-time updates on scraping and agent progress
+- Ability to modify agent configurations on-the-fly
+
+## Requirements
+
+- Python 3.7+
+- Firecrawl API key
+- OpenAI API key
+
+## Setup
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/your-username/swarm-firecrawl-marketing-agent.git
+   cd swarm-firecrawl-marketing-agent
+   ```
+
+2. Install the required packages:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Set up your environment variables in a `.env` file:
+   ```
+   OPENAI_API_KEY=your_openai_api_key
+   FIRECRAWL_API_KEY=your_firecrawl_api_key
+   ```
+
+## Usage
+
+### User Interface
+
+To use the Gradio-based user interface:
+
+1. Run the user interface:
+   ```
+   python user_interface.py
+   ```
+
+2. In the Gradio interface:
+   - The URL is pre-filled with https://www.okgo.app/, but you can change it if needed.
+   - Click "Scrape Website" to fetch the content.
+   - Modify agent configurations in the respective tabs if desired.
+   - Click "Run Workflow" to process the scraped content through the SwarmEditor.
+
+### Configuration
+
+The system uses a configuration file to define the agents in the swarm. You can modify the `swarm_config.json` file to change the number of agents, their names, and instructions.
+
+Example configuration:
+```json
+{
+  "agents": [
+    {
+      "name": "Agent 1",
+      "instructions": "Process the input data and provide initial insights."
+    },
+    {
+      "name": "Agent 2",
+      "instructions": "Analyze the insights from Agent 1 and generate recommendations."
+    },
+    {
+      "name": "Agent 3",
+      "instructions": "Create a final report based on the recommendations from Agent 2."
+    }
+  ]
+}
+```
+
+### Integration Test
+
+To run the integration test:
+
+```
+python integration_test.py
+```
+
+This will use Firecrawl to scrape https://www.okgo.app/, then pass the scraped content through the SwarmEditor workflow, and finally output the result to stdout.
+
+## Project Structure
+
+- `swarm_editor.py`: Contains the SwarmEditor class for managing the agent swarm.
+- `user_interface.py`: Implements the Gradio-based user interface.
+- `integration_test.py`: Provides an end-to-end test of the system.
+- `swarm_config.json`: Configuration file for defining the agent swarm.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

gradio_ui.py

@@ -0,0 +1,79 @@
+import gradio as gr
+from main import user_interface_agent, scrape_website, analyze_website_content, create_campaign_idea, generate_copy
+from swarm import Swarm, Agent, Response
+from typing import Dict, Any
+
+class GradioSwarmApp:
+    def __init__(self):
+        self.client = Swarm()
+        self.messages = []
+        self.agent = user_interface_agent
+        self.context_variables = {}
+
+    def process_message(self, message: str) -> Dict[str, Any]:
+        self.messages.append({"role": "user", "content": message})
+        response = self.client.run(
+            agent=self.agent,
+            messages=self.messages,
+            context_variables=self.context_variables,
+            stream=False
+        )
+        self.messages.extend(response.messages)
+        self.agent = response.agent
+        self.context_variables.update(response.context_variables)
+        return self.format_response(response)
+
+    def format_response(self, response: Response) -> Dict[str, Any]:
+        formatted_response = {
+            "assistant_message": "",
+            "scraper_output": "",
+            "agent_outputs": []
+        }
+        
+        for message in response.messages:
+            if message["role"] == "assistant":
+                formatted_response["assistant_message"] += f"{message['sender']}: {message['content']}\n"
+            elif message["role"] == "tool":
+                if message["tool_name"] == "scrape_website":
+                    formatted_response["scraper_output"] = message["content"]
+                else:
+                    formatted_response["agent_outputs"].append(f"{message['tool_name']}:\n{message['content']}")
+        
+        return formatted_response
+
+def create_ui():
+    app = GradioSwarmApp()
+    
+    with gr.Blocks() as interface:
+        gr.Markdown("# Swarm Firecrawl Marketing Agent")
+        
+        with gr.Row():
+            input_text = gr.Textbox(label="Enter URL or message")
+            submit_btn = gr.Button("Submit")
+        
+        with gr.Row():
+            assistant_output = gr.Textbox(label="Assistant Output", lines=10)
+        
+        with gr.Row():
+            scraper_output = gr.Textbox(label="Scraper Output", lines=10)
+            agent_outputs = gr.Textbox(label="Agent Outputs", lines=10)
+        
+        def process_input(message):
+            response = app.process_message(message)
+            return (
+                response["assistant_message"],
+                response["scraper_output"],
+                "\n\n".join(response["agent_outputs"])
+            )
+        
+        submit_btn.click(
+            process_input,
+            inputs=[input_text],
+            outputs=[assistant_output, scraper_output, agent_outputs]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    ui = create_ui()
+    ui.launch()

integration_test.py

@@ -0,0 +1,39 @@
+from swarm_editor import SwarmEditor
+from firecrawl import FirecrawlApp
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+def scrape_website(url):
+    api_key = os.getenv("FIRECRAWL_API_KEY")
+    if not api_key:
+        raise ValueError("FIRECRAWL_API_KEY environment variable not set")
+    
+    app = FirecrawlApp(api_key=api_key)
+    scrape_status = app.scrape_url(
+        url,
+        params={'formats': ['markdown']}
+    )
+    return scrape_status.get('markdown', 'No content scraped')
+
+def integration_test():
+    # Create SwarmEditor instance
+    editor = SwarmEditor()
+
+    # Load configuration from JSON file
+    editor.load_configuration('swarm_config.json')
+
+    # Scrape the website using Firecrawl
+    url = "https://www.okgo.app/"
+    scraped_content = scrape_website(url)
+
+    # Run the workflow with scraped content as initial input
+    response = editor.run_workflow(scraped_content)
+
+    # Output the result of the final agent to stdout
+    print("Final output:")
+    print(response.messages[-1]["content"])
+
+if __name__ == "__main__":
+    integration_test()

main.py

@@ -0,0 +1,108 @@
+import os
+from firecrawl import FirecrawlApp
+from swarm import Agent
+from swarm.repl import run_demo_loop
+import dotenv
+from openai import OpenAI
+
+dotenv.load_dotenv()
+
+# Initialize FirecrawlApp and OpenAI
+app = FirecrawlApp(api_key=os.getenv("FIRECRAWL_API_KEY"))
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+def scrape_website(url):
+    """Scrape a website using Firecrawl."""
+    scrape_status = app.scrape_url(
+        url,
+        params={'formats': ['markdown']}
+    )
+    return scrape_status
+
+def generate_completion(role, task, content):
+    """Generate a completion using OpenAI."""
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": f"You are a {role}. {task}"},
+            {"role": "user", "content": content}
+        ]
+    )
+    return response.choices[0].message.content
+
+def analyze_website_content(content):
+    """Analyze the scraped website content using OpenAI."""
+    analysis = generate_completion(
+        "marketing analyst",
+        "Analyze the following website content and provide key insights for marketing strategy.",
+        content
+    )
+    return {"analysis": analysis}
+
+def generate_copy(brief):
+    """Generate marketing copy based on a brief using OpenAI."""
+    copy = generate_completion(
+        "copywriter",
+        "Create compelling marketing copy based on the following brief.",
+        brief
+    )
+    return {"copy": copy}
+
+def create_campaign_idea(target_audience, goals):
+    """Create a campaign idea based on target audience and goals using OpenAI."""
+    campaign_idea = generate_completion(
+        "marketing strategist",
+        "Create an innovative campaign idea based on the target audience and goals provided.",
+        f"Target Audience: {target_audience}\nGoals: {goals}"
+    )
+    return {"campaign_idea": campaign_idea}
+
+def handoff_to_copywriter():
+    """Hand off the campaign idea to the copywriter agent."""
+    return copywriter_agent
+
+def handoff_to_analyst():
+    """Hand off the website content to the analyst agent."""
+    return analyst_agent
+
+def handoff_to_campaign_idea():
+    """Hand off the target audience and goals to the campaign idea agent."""
+    return campaign_idea_agent
+
+def handoff_to_website_scraper():
+    """Hand off the url to the website scraper agent."""
+    return website_scraper_agent
+
+user_interface_agent = Agent(
+    name="User Interface Agent",
+    instructions="You are a user interface agent that handles all interactions with the user. You need to always start with a URL that the user wants to create a marketing strategy for. Ask clarification questions if needed. Be concise.",
+    functions=[handoff_to_website_scraper],
+)
+
+website_scraper_agent = Agent(
+    name="Website Scraper Agent",
+    instructions="You are a website scraper agent specialized in scraping website content.",
+    functions=[scrape_website, handoff_to_analyst],
+)
+
+analyst_agent = Agent(
+    name="Analyst Agent",
+    instructions="You are an analyst agent that examines website content and provides insights for marketing strategies. Be concise.",
+    functions=[analyze_website_content, handoff_to_campaign_idea],
+)
+
+campaign_idea_agent = Agent(
+    name="Campaign Idea Agent",
+    instructions="You are a campaign idea agent that creates innovative marketing campaign ideas based on website content and target audience. Be concise.",
+    functions=[create_campaign_idea, handoff_to_copywriter],
+)
+
+copywriter_agent = Agent(
+    name="Copywriter Agent",
+    instructions="You are a copywriter agent specialized in creating compelling marketing copy based on website content and campaign ideas. Be concise.",
+    functions=[generate_copy],
+)
+
+if __name__ == "__main__":
+    # Run the demo loop with the user interface agent
+    run_demo_loop(user_interface_agent, stream=True)

requirements.txt

@@ -0,0 +1,4 @@
+firecrawl-py
+openai
+git+http://git@github.com/openai/swarm.git
+gradio

swarm_config.json

@@ -0,0 +1,16 @@
+{
+  "agents": [
+    {
+      "name": "Analyst",
+      "instructions": "Analyze the scraped content and provide insights."
+    },
+    {
+      "name": "Campaign Idea Generator",
+      "instructions": "Generate campaign ideas based on the analysis."
+    },
+    {
+      "name": "Copywriter",
+      "instructions": "Create compelling copy based on the campaign idea."
+    }
+  ]
+}

swarm_editor.py

@@ -0,0 +1,44 @@
+from swarm import Swarm, Agent
+from swarm.core import Result
+import json
+from typing import Dict, List
+
+class SwarmEditor:
+    def __init__(self):
+        self.agents: List[Agent] = []
+        self.swarm = Swarm()
+
+    def add_agent(self, name: str, instructions: str):
+        self.agents.append(Agent(
+            name=name,
+            instructions=instructions
+        ))
+
+    def update_agent(self, index: int, name: str, instructions: str):
+        if 0 <= index < len(self.agents):
+            self.agents[index] = Agent(
+                name=name,
+                instructions=instructions
+            )
+
+    def load_configuration(self, config_file: str):
+        with open(config_file, 'r') as f:
+            config = json.load(f)
+        
+        self.agents = []
+        for agent_config in config['agents']:
+            self.add_agent(agent_config['name'], agent_config['instructions'])
+
+    def run_workflow(self, initial_input: str):
+        response = None
+        context_variables = {}
+        for agent in self.agents:
+            response = self.swarm.run(
+                agent=agent,
+                messages=[{"role": "user", "content": initial_input}] if response is None else response.messages,
+                context_variables=context_variables,
+                max_turns=1
+            )
+            context_variables.update(response.context_variables)
+            initial_input = response.messages[-1]["content"]
+        return response

user_interface.py

@@ -0,0 +1,68 @@
+import gradio as gr
+import json
+from swarm_editor import SwarmEditor
+from firecrawl import FirecrawlApp
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+CONFIG_FILE = 'swarm_config.json'
+
+class UserInterface:
+    def __init__(self):
+        self.swarm_editor = SwarmEditor()
+        self.firecrawl_app = FirecrawlApp(api_key=os.getenv("FIRECRAWL_API_KEY"))
+        self.load_config()
+
+    def load_config(self):
+        with open(CONFIG_FILE, 'r') as f:
+            self.config = json.load(f)
+        self.swarm_editor.load_configuration(CONFIG_FILE)
+        return self.config
+
+    def scrape_website(self, url):
+        scrape_status = self.firecrawl_app.scrape_url(
+            url,
+            params={'formats': ['markdown']}
+        )
+        return scrape_status.get('markdown', 'No content scraped')
+
+    def update_agent(self, index, name, instructions):
+        self.swarm_editor.update_agent(index, name, instructions)
+        return f"Agent {index} updated"
+
+    def run_workflow(self, scraped_content):
+        response = self.swarm_editor.run_workflow(scraped_content)
+        return response.messages[-1]["content"]
+
+    def launch(self):
+        with gr.Blocks() as interface:
+            gr.Markdown("# Agent Workflow Editor")
+            
+            url = gr.Textbox(label="URL to Scrape", value="https://www.lazzloe.com/")
+            scrape_button = gr.Button("Scrape Website")
+            scraped_content = gr.Textbox(label="Scraped Content")
+            
+            agent_tabs = gr.Tabs()
+            
+            with agent_tabs:
+                for i, agent in enumerate(self.config['agents']):
+                    with gr.Tab(f"Agent {i}"):
+                        name = gr.Textbox(label="Name", value=agent['name'])
+                        instructions = gr.Textbox(label="Instructions", value=agent['instructions'], lines=3)
+                        update_button = gr.Button(f"Update Agent {i}")
+                        update_output = gr.Textbox(label="Update Status")
+                        update_button.click(self.update_agent, inputs=[gr.Number(value=i, visible=False), name, instructions], outputs=[update_output])
+            
+            run_button = gr.Button("Run Workflow")
+            workflow_output = gr.Textbox(label="Workflow Output")
+
+            scrape_button.click(self.scrape_website, inputs=[url], outputs=[scraped_content])
+            run_button.click(self.run_workflow, inputs=[scraped_content], outputs=[workflow_output])
+
+        interface.launch()
+
+if __name__ == "__main__":
+    ui = UserInterface()
+    ui.launch()