updated all files

README.md

@@ -1,13 +1,50 @@
----
-title: ContentGenerationWorkflow
-emoji: 💻
-colorFrom: yellow
-colorTo: red
-sdk: streamlit
-sdk_version: 1.34.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+### Project Description
+Implementing a scalable content team using AI involves creating a framework that blends the strengths of AI technologies with the creative and supervisory capabilities of human team members. This strategy aims to enhance efficiency, creativity, and content output quality.
+
+This code is a high-level conceptualization and would require adaptation to fit the actual CrewAI framework and toolset specifics. It illustrates how different AI agents, equipped with specialized roles and tools, can collaborate within a content creation process. Each agent focuses on a key area—research, writing, and SEO—streamlining the content development workflow and enhancing output quality through specialized AI-driven tasks.
+
+### Objective
+Implement a content generation workflow using the Crew AI framework. This workflow should autonomously process input topics, conduct research, plan content, generate images, optimize for SEO, and perform final editorial checks.
+
+### Tools and Frameworks:
+* Crew AI framework
+* Streamlit - User Interface(UI)
+* Python for scripting
+* AI models or APIs (e.g., `gemini-pro` for content, `stable-diffusion-xl-base` for images)
+
+### Prerequisites
+To complete this project, you should understand Python programming, data manipulation, visualization libraries such as Pandas and Matplotlib, and machine learning libraries such as Scikit-Learn. Additionally, some background knowledge of natural language processing (NLP) techniques and generate text to image and image to text methods would be helpful.
+
+### Resources
+- Live demo link: [Article Generate using CrewAI]()
+- Check out  [CrewAI](https://docs.crewai.com/)
+- Project code [GitHub](https://github.com/Bhavik-Jikadara/Content-Generation-Workflow.git)
+
+-----------------------------------------------------------------------------------------------------------------
+## Notes: This step is very import:
+### [Click here](https://www.c-sharpcorner.com/article/how-to-addedit-path-environment-variable-in-windows-11/) to set three API_KEYs in the Environment Variable, and use this link as a reference.
+* [Click here to OpenAI API Key](https://platform.openai.com/api-keys)
+
+    $ OPENAI_API_KEY="Your-API-key" 
+* [Click here to Google API Key](https://aistudio.google.com/)  
+
+    $ GOOGLE_API_KEY="Your-API-key" 
+* [Click here to Serper API Key](https://serper.dev/api-key)  
+ 
+    $ SERPER_API_KEY="Your-API-key"
+-----------------------------------------------------------------------------------------------------------------         
+
+### Step 1: Clone the repository
+    $ git clone https://github.com/Bhavik-Jikadara/Content-Generation-Workflow.git
+    $ cd Content-Generation-Workflow/
+
+### Step 2: Create a virtualenv (windows user)
+    $ pip install virtualenv
+    $ virtualenv venv
+    $ source venv/Scripts/activate
+
+### Step 3: Install the requirements libraries using pip
+    $ pip install -r requirements.txt
+
+### Step 4: Type this command and run the project:
+    $ streamlit run Home.py

app.py

@@ -1,7 +1,98 @@
 import streamlit as st
+from src.components.process import all_crew
+from dotenv import load_dotenv
+load_dotenv()
 
-st.title("Welcome to the Streamlit app")
 
-st.write("""
-Welcome, we're glad to have someone on our team who believes in the same things we do. We are excited to use your skills and experience to make things better. Hi, we're from (organization name), and we're happy to assist you in getting started. Don't hesitate to ask us anything you need.
-""")
+class ContentGenerationUI:
+
+    def generate_content(self, topic):
+        inputs = {
+            "topic": topic
+        }
+        result = all_crew.kickoff(inputs=inputs)
+        return result
+
+    def content_generation(self):
+        if st.session_state.generating:
+            st.session_state.content_generator = self.generate_content(
+                st.session_state.topic)
+
+        if st.session_state.content_generator and st.session_state.content_generator != "":
+            with st.container():
+                st.write("Content generated successfully!")
+                st.download_button(
+                    label="Download Markdown file",
+                    data=st.session_state.content_generator,
+                    file_name="content_generate.md",
+                    mime="text/markdown"
+                )
+            st.session_state.generating = False
+
+    def sidebar(self):
+        with st.sidebar:
+            st.title("Content Generator Tool")
+            st.write("This workflow should autonomously process input topics, conduct research, plan content, generate images, optimize for SEO, and perform final editorial checks.")
+
+            topic = st.text_area(
+                label="Enter the topic: ",
+                placeholder="Enter the name of the topic to generate the article",
+                key="topic",
+                height=175
+            )
+            st.write(f'You wrote {len(topic.split())} words.')
+
+            if st.button("Generate Content"):
+                st.session_state.generating = True
+
+    def render(self):
+        st.set_page_config(page_title="Content Generation", page_icon="📃")
+        tab1, tab2 = st.tabs(["Output", "About Project"])
+
+        # This is sidebar section
+        self.sidebar()
+
+        with tab2:
+            st.markdown("# About project")
+            st.write(
+                """
+                ### Project Description
+                Implementing a scalable content team using AI involves creating a framework that blends the strengths of AI technologies with the creative and supervisory capabilities of human team members. This strategy aims to enhance efficiency, creativity, and content output quality.
+
+                This code is a high-level conceptualization and would require adaptation to fit the actual CrewAI framework and toolset specifics. It illustrates how different AI agents, equipped with specialized roles and tools, can collaborate within a content creation process. Each agent focuses on a key area—research, writing, and SEO—streamlining the content development workflow and enhancing output quality through specialized AI-driven tasks.
+                
+                ### Objective
+                Implement a content generation workflow using the Crew AI framework. This workflow should autonomously process input topics, conduct research, plan content, generate images, optimize for SEO, and perform final editorial checks.
+                
+                ### Tools and Frameworks:
+                * Crew AI framework
+                * Streamlit - User Interface(UI)
+                * Python for scripting
+                * AI models or APIs (e.g., `gemini-pro` for content, `stable-diffusion-xl-base` for images)
+
+                ### Prerequisites
+                To complete this project, you should understand Python programming, data manipulation, visualization libraries such as Pandas and Matplotlib, and machine learning libraries such as Scikit-Learn. Additionally, some background knowledge of natural language processing (NLP) techniques and generate text to image and image to text methods would be helpful.
+
+                ### Resources
+                - Live demo link: [Content Generate - WebApp]()
+                - Check out  [CrewAI](https://docs.crewai.com/)
+                - Project code [GitHub](https://github.com/Bhavik-Jikadara/Content-Generation-Workflow)
+                """
+            )
+
+        with tab1:
+            # Initialize the app session state
+            if "topic" not in st.session_state:
+                st.session_state.topic = ""
+
+            if "content_generator" not in st.session_state:
+                st.session_state.content_generator = ""
+
+            if "generating" not in st.session_state:
+                st.session_state.generating = False
+
+            self.content_generation()
+
+
+if __name__ == "__main__":
+    ContentGenerationUI().render()

requirements.txt

@@ -0,0 +1,9 @@
+crewai
+crewai[tools]
+openai
+streamlit
+duckduckgo-search
+langchain-google-genai
+python-dotenv
+requests
+beautifulsoup4

src/components/agents.py

@@ -0,0 +1,119 @@
+from crewai import Agent
+from src.utils import llm, search_tool, step_callback
+from src.exception import CustomException
+from src.components.image_generate import image_generate
+import sys
+
+
+try:
+    researcher_agent = Agent(
+        role="Researcher Agent",
+        goal="Your goal is to assists in content research by gathering, analyzing, and summarizing information on specified topics.",
+        backstory="""
+        ### You are conducting keyword research and identifying trending topics relevant to the content strategy.
+        - This involves using various tools and techniques to identify keywords and topics that are relevant to the content strategy of the organization.
+        - Keyword research helps in understanding what topics are popular among the target audience and what keywords are commonly used in search queries related to the organization's industry or niche.
+        - Identifying trending topics allows the organization to capitalize on current trends and create content that is timely and relevant.
+
+        ### Also, you are collecting data and insights from reputable sources to support content creation.
+        - This involves gathering data and information from reputable sources such as research papers, industry reports, authoritative websites, and credible publications.
+        - The collected data and insights serve as valuable resources for content creation, providing facts, statistics, case studies, and other supporting evidence to strengthen the content's credibility and relevance.
+        - Data collection may include conducting surveys, interviews, or market research to gather firsthand insights from target audiences or industry experts.
+
+        ### Finally, you are proving summaries and briefs to human content creators to streamline their research phase.
+        - This responsibility entails summarizing the gathered information and insights into concise and actionable briefs for human content creators.
+        - Summaries and briefs help content creators quickly grasp the key points and main findings of the research, saving time and effort during the content creation process.
+        - By providing organized and digestible summaries, the AI Research Assistant enables content creators to focus on creative ideation, storytelling, and content development rather than spending excessive time on research and information gathering.
+        """,
+        tools=[search_tool],
+        verbose=True,
+        max_iter=5,
+        allow_delegation=True,
+        step_callback=lambda step: step_callback(
+            agent_output=step, agent_name="Research Agent")
+    )
+
+    content_creator_agent = Agent(
+        role="Content Creator",
+        goal="Your goal is to generate initial drafts of content based on templates, guidelines, and inputs for the research phase.",
+        backstory="""
+        - **Creating Initial Content Drafts for Various Formats:** This involves using natural language generation (NLG) technologies to generate preliminary drafts of content in different formats, such as blog posts, articles, and social media updates. NLG technologies use algorithms to analyze data and generate human-like text based on predefined rules, templates, or machine learning models. By leveraging NLG, content creators can quickly generate draft content that can then be refined and customized as needed.
+
+        - **Adhering to Brand Voice, Style Guides, and Content Objectives:** Content creators must ensure that the generated content aligns with the brand's voice and adheres to established style guides and content objectives. This includes maintaining consistency in tone, language, and messaging across all content assets to reinforce the brand identity and messaging strategy. Content strategists may provide guidelines and objectives to ensure that the content effectively communicates the brand's values, resonates with the target audience, and supports broader marketing goals.
+
+        - **Generating Creative Ideas for Content:** In addition to generating draft content, content creators are responsible for brainstorming and developing creative ideas for content campaigns. This includes crafting engaging headlines, taglines, and calls-to-action that capture the audience's attention and compel them to take action. Creativity is essential in devising unique and compelling content concepts that differentiate the brand from competitors and resonate with the target audience's interests and preferences.
+        """,
+        llm=llm,
+        verbose=True,
+        max_iter=5,
+        allow_delegation=True,
+        step_callback=lambda step: step_callback(
+            agent_output=step, agent_name="Content Creator Agent")
+    )
+
+    content_curator_agent = Agent(
+        role="Content Curatorr",
+        goal="Identifies and curates relevant external content to share with the audience, enhancing brand authority and engagement.",
+        backstory="""
+        - The AI Agent continuously monitors a wide array of sources such as websites, blogs, social media platforms, news outlets, and databases. It uses advanced algorithms to filter through this vast amount of information and identify content that is relevant to the target audience or specific topic of interest.
+        
+        - Once relevant content is identified, the AI Agent analyzes and processes it to generate concise summaries and provide context. It may extract key points, insights, or quotes from articles, videos, or other media and reframe them in a format suitable for the intended audience or platform. This ensures that the curated content is digestible and adds value to the audience.
+
+        - Content Curator AI Agents are capable of tailoring curated content for various platforms and formats. Whether it's social media posts, blog articles, email newsletters, or video scripts, the AI Agent optimizes the content to fit the style, tone, and requirements of each platform.
+        """,
+        step_callback=lambda step: step_callback(
+            agent_output=step, agent_name="Content Curator Agent")
+    )
+
+    visual_content_creator_agent = Agent(
+        role="Visual Content Creator",
+        goal="Generates visual content such as images, infographics, and simple videos to complement textual content.",
+        backstory="""
+        - **Creating Visual Content Based on Textual Content Themes and Highlights:** Visual content creators translate textual content into engaging visuals, such as graphics, images, infographics, videos, or animations, to represent key themes and messages. This enhances audience engagement and understanding of the content.
+
+        - **Adhering to Brand Visual Guidelines and Aesthetics:** Visual content must align with the brand's visual identity, using consistent colors, fonts, logos, and design elements. This maintains brand consistency and reinforces brand recognition across different platforms.
+
+        - **Automatically Resizing and Adapting Visual Content for Different Platforms and Devices:** Visual content creators optimize assets for various screen sizes and platforms, ensuring they look great and perform well across devices. Techniques like responsive design and media queries are used to achieve this.
+        """,
+        verbose=True,
+        tools=[image_generate],
+        step_callback=lambda step: step_callback(
+            agent_output=step, agent_name="Visual Content creator Agent")
+    )
+
+    seo_analyst_agent = Agent(
+        role="SEO Analyst",
+        goal="Optimizes content for search engines and improves content discoverability online.",
+        backstory="""
+        - **Analyzing Content for SEO Best Practices:** Content analysts assess content to ensure it adheres to SEO best practices, including keyword density, meta descriptions, and title tags. This optimization enhances content visibility and ranking on search engine results pages (SERPs).
+
+        - **Recommending Improvements to Enhance Content Ranking:** Content analysts suggest improvements based on their analysis to enhance content ranking. This includes suggesting additional keywords, refining meta descriptions, and optimizing title tags to increase relevance and authority in the eyes of search engines.
+        
+        - **Monitoring Content Performance and Providing Insights:** Content analysts continuously monitor content performance, including organic search traffic and user engagement metrics. They provide insights for content optimization by identifying underperforming content and recognizing successful content strategies for future campaigns. These insights drive continuous improvement in search engine visibility and performance.
+        """,
+        verbose=True,
+        allow_delegation=True,
+        step_callback=lambda step: step_callback(
+            agent_output=step, agent_name="SEO Analyst Agent")
+    )
+
+    editorial_assistant_agent = Agent(
+        role="Editorial Assistant",
+        goal="Your goal is to implement a review process to check the content for accuracy, coherence, grammar, and style. Make necessary adjustments.",
+        backstory="""
+        - Detailed Grammar and Spelling Checks: The Editorial Assistant meticulously examines content to identify and rectify any grammatical or spelling errors. This involves scrutinizing each sentence and paragraph to ensure correctness in language usage.
+        
+        - Stylistic Adjustments:
+        In addition to grammar and spelling, the Editorial Assistant makes stylistic adjustments to harmonize content with the publication's designated tone and style guidelines. This involves refining sentences, adjusting word choices, and ensuring consistency throughout the text.
+        
+        - Conducting Final Reviews:
+        The Editorial Assistant performs thorough final reviews to verify the readiness of content for publication. This entails assessing all aspects of the content, including grammar, spelling, style, formatting, and adherence to publication standards.
+        """,
+        verbose=True,
+        step_callback=lambda step: step_callback(
+            agent_output=step, agent_name="Editorial Assistant Agent")
+    )
+
+
+except Exception as e:
+    raise CustomException(e, sys)

src/components/image_generate.py

@@ -0,0 +1,41 @@
+from PIL import Image
+import io
+import os
+import requests
+from crewai_tools import tool
+
+# API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+# hugginface_api_key = os.getenv("HUGGINGFACE_API_KEY")
+# headers = {"Authorization": f"Bearer {hugginface_api_key}"}
+# def query(payload):
+#     response = requests.post(API_URL, headers=headers, json=payload)
+#     return response.content
+# def generate_image(input: str):
+#     """Create an image based on input"""
+#     image_bytes = query({
+#         "inputs": input,
+#     })
+#     # You can access the image with PIL.Image for example
+
+#     image = Image.open(io.BytesIO(image_bytes))
+#     name = input.split(" ")[0]
+#     image.save(f"images/generate_{name}.jpg")
+#     return image
+
+@tool("Image Generate Tool")
+def image_generate(context: str):
+    """This is Image generate tool"""
+    API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+    hugginface_api_key = os.getenv("HUGGINGFACE_API_KEY")
+    headers = {"Authorization": f"Bearer {hugginface_api_key}"}
+
+    def query(payload):
+        response = requests.post(API_URL, headers=headers, json=payload)
+        return response.content
+    image_bytes = query({
+        "inputs": context,
+    })
+    name = context.split(" ")[0]
+    image = Image.open(io.BytesIO(image_bytes)).resize((1024, 1024))
+    image.save(f"outputs/generate_{name}.jpg")
+    return image

src/components/process.py

@@ -0,0 +1,17 @@
+"""
+Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks, now with the option to configure language models for enhanced interaction.
+"""
+
+from crewai import Crew, Process
+from src.components.agents import researcher_agent, content_creator_agent, seo_analyst_agent, visual_content_creator_agent, editorial_assistant_agent, content_curator_agent
+from src.components.tasks import researcher_task, content_creator_task, seo_analyst_task, visual_content_creator_task, editorial_assistant_task, content_curator_task
+
+
+# all crew
+all_crew = Crew(
+    agents=[researcher_agent, content_creator_agent, content_curator_agent, seo_analyst_agent,
+            visual_content_creator_agent, editorial_assistant_agent],
+    tasks=[researcher_task, content_creator_task, content_curator_task, seo_analyst_task,
+            visual_content_creator_task, editorial_assistant_task],
+    process=Process.sequential
+)

src/components/tasks.py

@@ -0,0 +1,107 @@
+from src.exception import CustomException
+from crewai import Task
+from src.components.agents import researcher_agent, content_creator_agent, visual_content_creator_agent, seo_analyst_agent, editorial_assistant_agent, content_curator_agent
+import sys
+from src.utils import llm
+
+try:
+    researcher_task = Task(
+        description="""
+        These responsibilities highlight the role of the AI Research Assistant in supporting the content creation process by leveraging AI and machine learning techniques to streamline research, gather relevant data and insights, and facilitate collaboration between AI and human content creators based on the user input {topic}.
+        """,
+        agent=researcher_agent,
+        expected_output="""
+        Structuring a content plan that includes headings, subheadings, and key points to cover for the {topic}.
+
+        Exaple output:
+        ### Title: The Role of AI in Healthcare
+
+        ### Introduction:
+        - Brief overview of ....
+
+        ### 1: AI Applications in Diagnosis and Disease Detection
+        * 1.1: Medical Imaging and Radiology
+            * Key points:
+                - Use of AI algorithms to analyze medical images (X-rays, MRIs, CT scans) for early detection of diseases.
+                - Improved accuracy and efficiency in identifying abnormalities and diagnosing conditions such as cancer, fractures, and cardiovascular diseases.
+        * 1.2: .......
+
+        ### Conclusion:
+        - Summary of the key roles and applications of AI in healthcare, from diagnosis and treatment to personalized medicine and remote monitoring.
+        - Discussion of the potential benefits and challenges of AI adoption in healthcare, along with considerations for future developments.
+        - Call-to-action encouraging readers to stay informed about advancements in AI healthcare and to engage in discussions about the ethical and regulatory implications.
+        - Closing remarks emphasizing the transformative potential of AI in improving patient care and shaping the future of healthcare delivery.
+
+        """,
+        llm=llm,
+        output_file="outputs/content_creator.md"
+    )
+
+    content_creator_task = Task(
+        description="""
+        The role of generating initial drafts of content requires a blend of creativity, research skills, attention to detail, and adherence to guidelines. By effectively translating research insights into compelling content drafts, content creators lay the groundwork for successful content marketing campaigns that resonate with the target audience and achieve business objectives.
+        """,
+        agent=content_creator_agent,
+        expected_output="""
+        - Based on the content plan, generate a draft using an AI text-generation model. This should form the body of your content.
+        - Generating creative ideas for content, including headlines, taglines, and calls-to-action.
+        """,
+        llm=llm
+    )
+
+    content_curator_task = Task(
+        description="""
+        The Content Curator plays a pivotal role in guaranteeing that published content is error-free, stylistically appropriate, and prepared to meet the publication's standards and expectations.
+        """,
+        agent=content_curator_agent,
+        expected_output="""
+        - Apply SEO best practices to the generated content. This may involve:
+            - Keyword optimization.
+            - Meta tags and descriptions.
+            - Readability improvements.
+
+        The expected output of a Content Curator is optimizing content for SEO best practices, including keyword density, meta descriptions, and title tags. Recommending improvements to enhance content ranking on search engines. Monitoring content performance and providing insights for content optimization.
+        """,
+        llm=llm,
+        context=[researcher_task]
+    )
+
+    visual_content_creator_task = Task(
+        description="""
+        Incorporate an AI-based image generation model to create relevant images for the content. Ensure these images are saved locally.
+        """,
+        agent=visual_content_creator_agent,
+        expected_output="""Generate a .png or .jpg file image based on the input and return it in images folder."""
+    )
+
+    seo_analyst_task = Task(
+        description="""
+        The role involves optimizing content for search engines by analyzing, recommending improvements, and monitoring performance, ultimately aiming to enhance content discoverability online and improve its ranking on search engine results pages.
+        """,
+        agent=seo_analyst_agent,
+        expected_output="""
+        Apply SEO best practices to the generated content. This may involve:
+        - Keyword optimization.
+        - Meta tags and descriptions.
+        - Readability improvements.
+
+        The expected output of an SEO Analyst is analyzing content for SEO best practices, including keyword density, meta descriptions, and title tags. Recommending improvements to enhance content ranking on search engines. Monitoring content performance and providing insights for content optimization.
+        """,
+        context=[content_creator_task]
+    )
+
+    editorial_assistant_task = Task(
+        description="""
+        The Editorial Assistant plays a pivotal role in guaranteeing that published content is error-free, stylistically appropriate, and prepared to meet the publication's standards and expectations.
+        """,
+        agent=editorial_assistant_agent,
+        expected_output="""
+        The expected output is high-quality content that is polished, accurate, and in line with the publication's editorial standards, ensuring a positive reader experience and maintaining the publication's reputation for excellence.
+        """,
+        context=[seo_analyst_task],
+        output_file="outputs/content_creator.md"
+    )
+
+
+except Exception as err:
+    raise CustomException(err, sys)

src/exception.py

@@ -0,0 +1,22 @@
+import sys
+from src.logger import logging
+
+# custom error handling
+
+
+def error_message_detail(error, error_detail: sys):
+    _, _, exc_tb = error_detail.exc_info()
+    filename = exc_tb.tb_frame.f_code.co_filename
+    error_message = "Error occured in python script name [{0}] line number [{1}] error message [{2}]".format(
+        filename, exc_tb.tb_lineno, str(error))
+    return error_message
+
+
+class CustomException(Exception):
+    def __init__(self, error_message, error_details: sys) -> None:
+        super().__init__(error_message)
+        self.error_message = error_message_detail(error_message, error_details)
+
+    # return error message
+    def __str__(self):
+        return self.error_message

src/logger.py

@@ -0,0 +1,15 @@
+import logging
+import os
+from datetime import datetime
+
+LOG_FILE = f"{datetime.now().strftime('%m_%d_%Y_%H_%M_%S')}.log"
+logs_path = os.path.join(os.getcwd(), "logs", LOG_FILE)
+os.makedirs(logs_path, exist_ok=True)
+
+LOG_FILE_PATH = os.path.join(logs_path, LOG_FILE)
+
+logging.basicConfig(
+    filename=LOG_FILE_PATH,
+    format="[ %(asctime)s ] %(lineno)d %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO
+)

src/utils.py

@@ -0,0 +1,52 @@
+from langchain_google_genai import GoogleGenerativeAI
+from crewai_tools import SerperDevTool
+import datetime
+import json
+import os
+import streamlit as st
+from typing import Dict, List, Tuple, Union
+from langchain_core.agents import AgentFinish
+from dotenv import load_dotenv
+load_dotenv()
+
+# search tool
+search_tool = SerperDevTool(n_results=5)
+# model for generate content
+llm = GoogleGenerativeAI(
+    model="gemini-pro", google_api_key=os.getenv("GOOGLE_API_KEY"))
+
+
+# Step_callback function
+def step_callback(agent_output: Union[str, List[Tuple[Dict, str]], AgentFinish], agent_name, *args):
+    with st.chat_message("AI"):
+        # Try to parse the output if it is a JSON string
+        if isinstance(agent_output, str):
+            try:
+                agent_output = json.loads(agent_output)
+            except json.JSONDecodeError:
+                pass
+
+        if isinstance(agent_output, list) and all(
+            isinstance(item, tuple) for item in agent_output
+        ):
+
+            for action, description in agent_output:
+                # Print attributes based on assumed structure
+                st.write(f"Agent Name: {agent_name}")
+                st.write(f"Tool used: {getattr(action, 'tool', 'Unknown')}")
+                st.write(
+                    f"Tool input: {getattr(action, 'tool_input', 'Unknown')}")
+                st.write(f"{getattr(action, 'log', 'Unknown')}")
+                with st.expander("Show observation"):
+                    st.markdown(f"Observation\n\n{description}")
+
+        # Check if the output is a dictionary as in the second case
+        elif isinstance(agent_output, AgentFinish):
+            st.write(f"Agent Name: {agent_name}")
+            output = agent_output.return_values
+            st.write(f"I finished my task:\n{output['output']}")
+
+        # Handle unexpected formats
+        else:
+            st.write(type(agent_output))
+            st.write(agent_output)