Intial Code

.gitignore

@@ -0,0 +1,3 @@
+.env
+.venv
+__pycache__

gemini_history.py

@@ -0,0 +1,21 @@
+from google.genai.types import Part, Content, UserContent
+
+class ConversationBuilder:
+    def build_with_user_content(self, user_text: str):
+        response = [
+            UserContent(parts=[Part(text=user_text)]), # will get a role='user' automatically 
+        ]
+        return response
+
+    def build_with_content_only(self, model_text: str):
+        response = [
+            Content(parts=[Part(text=model_text)], role='model')
+        ]
+        return response
+
+    def build_combined(self, user_text: str, model_text: str):
+        response = [
+            UserContent(parts=[Part(text=user_text)]),
+            Content(parts=[Part(text=model_text)], role='model')
+        ]
+        return response

gemini_llm.py

@@ -0,0 +1,40 @@
+import os
+from google import genai
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class GeminiLLM:
+    def __init__(self, api_key=None):
+        self.api_key = api_key or os.environ.get("GEMINI_API_Key")
+        if not self.api_key:
+            raise ValueError("API key must be provided or set in the environment variable 'GEMINI_API_Key'")
+        try:
+            self.client = genai.Client(api_key=self.api_key)
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize Gemini client: {str(e)}")
+        self.model_id = "gemini-2.0-flash"
+
+    def generate_response(self, prompt: str) -> str:
+        try:
+            response = self.client.models.generate_content(
+                model=self.model_id,
+                contents=prompt,
+            )
+            if hasattr(response, "text"):
+                return response.text
+            raise RuntimeError("No response text received from model")
+        except Exception as e:
+            raise RuntimeError(f"Error generating response: {str(e)}")
+
+    def stream_response(self, prompt: str):
+        try:
+            stream = self.client.models.generate_content_stream(
+                model=self.model_id,
+                contents=prompt,
+            )
+            for chunk in stream:
+                if hasattr(chunk, "text") and chunk.text:
+                    yield chunk.text
+        except Exception as e:
+            yield f"Error during streaming: {str(e)}"

gemini_tool_selector.py

@@ -0,0 +1,87 @@
+import streamlit as st
+from google import genai
+from google.genai import types
+from gemini_tools import GeminiCodeExecutionTool, GeminiThinking, GoogleSearchTool
+from utils import get_typing_indicator_html
+
+class GeminiToolSelector():
+    def __init__(self) -> None:
+        pass
+
+    def handle_tool_response(self, tool_name, tool_args, geminillm):
+        if tool_name == "GeminiThinking":
+            gen = GeminiThinking(geminillm).activate_stream(tool_args['query'])
+            typing_placeholder = st.empty()
+            thought_placeholder = st.empty()
+            response_placeholder = st.empty()
+
+            thought_buffer = ""
+            streamed_output = ""
+
+            typing_placeholder.markdown(get_typing_indicator_html("Thinking"), unsafe_allow_html=True)
+
+            for chunk in gen:
+                if chunk["thought"]:
+                    thought_buffer += chunk["text"] + "\n"
+                    with thought_placeholder.expander("Thoughts (click to expand)", expanded=False):
+                        st.markdown(thought_buffer)
+                else:
+                    break
+
+            typing_placeholder.empty()
+
+            if chunk and not chunk["thought"]:
+                streamed_output += chunk["text"]
+                response_placeholder.markdown(streamed_output)
+
+            for chunk in gen:
+                if not chunk["thought"]:
+                    streamed_output += chunk["text"]
+                    response_placeholder.markdown(streamed_output)
+
+            return streamed_output
+
+        elif tool_name == "GoogleSearchTool":
+            gen = GoogleSearchTool(geminillm).activate_stream(tool_args['query'])
+            typing_placeholder = st.empty()
+            typing_placeholder.markdown(get_typing_indicator_html("Searching Web"), unsafe_allow_html=True)
+            response_placeholder = st.empty()
+
+            try:
+                first_chunk = next(gen)
+            except StopIteration:
+                first_chunk = ""
+
+            typing_placeholder.empty()
+            streamed_output = first_chunk
+            response_placeholder.markdown(streamed_output)
+
+            for chunk in gen:
+                streamed_output += chunk
+                response_placeholder.markdown(streamed_output)
+
+            return streamed_output
+
+        elif tool_name == "GeminiCodeExecutionTool":
+            gen = GeminiCodeExecutionTool(geminillm).activate_stream(tool_args['query'])
+            typing_placeholder = st.empty()
+            typing_placeholder.markdown(get_typing_indicator_html("Writing Code"), unsafe_allow_html=True)
+            response_placeholder = st.empty()
+
+            try:
+                first_chunk = next(gen)
+            except StopIteration:
+                first_chunk = ""
+
+            typing_placeholder.empty()
+            streamed_output = first_chunk
+            response_placeholder.markdown(streamed_output)
+
+            for chunk in gen:
+                streamed_output += chunk
+                response_placeholder.markdown(streamed_output)
+
+            return streamed_output
+
+        else:
+            return "Unknown tool triggered."

gemini_tools.py

@@ -0,0 +1,101 @@
+from google.genai import types
+from google.genai.types import Tool, GenerateContentConfig, GoogleSearch
+from gemini_llm import GeminiLLM
+from bs4 import BeautifulSoup
+import requests
+
+class GeminiThinking:
+    def __init__(self, geminillm: GeminiLLM, model_id="gemini-2.5-flash-preview-05-20"):
+        self.geminillm = geminillm
+        self.modelid = model_id
+
+    def activate_stream(self, prompt: str):
+        try:
+            stream = self.geminillm.client.models.generate_content_stream(
+                model=self.modelid,
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    thinking_config=types.ThinkingConfig(include_thoughts=True)
+                )
+            )
+
+            for chunk in stream:
+                if not chunk.candidates:
+                    continue
+
+                for part in chunk.candidates[0].content.parts:
+                    if hasattr(part, "thought") and part.thought:
+                        yield {"text": part.text, "thought": True}
+                    elif hasattr(part, "text") and part.text:
+                        yield {"text": part.text, "thought": False}
+
+        except Exception as e:
+            yield {"text": f"Error during GeminiThinking stream: {str(e)}", "thought": False}
+
+
+class GoogleSearchTool:
+    def __init__(self, geminillm: GeminiLLM):
+        self.geminillm = geminillm
+        self.tool = Tool(google_search=GoogleSearch())
+        self.response = None
+        self.grounding = None
+
+    def activate_stream(self, prompt: str):
+        try:
+            stream = self.geminillm.client.models.generate_content_stream(
+                model=self.geminillm.model_id,
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    tools=[self.tool],
+                    response_modalities=["TEXT"]
+                )
+            )
+
+            for chunk in stream:
+                if not chunk.candidates:
+                    continue
+
+                candidate = chunk.candidates[0]
+                self.grounding = candidate.grounding_metadata if hasattr(candidate, "grounding_metadata") else None
+
+                for part in candidate.content.parts:
+                    if hasattr(part, "text") and part.text:
+                        yield part.text
+
+        except Exception as e:
+            yield f"Error during GoogleSearchTool stream: {str(e)}"
+
+class GeminiCodeExecutionTool:
+    def __init__(self, geminillm: GeminiLLM):
+        self.geminillm = geminillm 
+
+    def activate_stream(self, prompt: str):
+        try:
+            stream = self.geminillm.client.models.generate_content_stream(
+                model=self.geminillm.model_id,
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    tools=[types.Tool(code_execution=types.ToolCodeExecution())],  
+                    response_modalities=["TEXT"]
+                ),
+            )
+
+            for chunk in stream:
+                if not chunk.candidates:
+                    continue
+
+                candidate = chunk.candidates[0]
+                for part in candidate.content.parts:
+                    if hasattr(part, "text") and part.text:
+                        yield part.text
+                    elif hasattr(part, "executable_code") and part.executable_code:
+                        yield f"\n\n```python\n{part.executable_code.code}\n```\n"
+                    elif hasattr(part, "code_execution_result") and part.code_execution_result:
+                        yield f"\n\n**Output:**\n```\n{part.code_execution_result.output}\n```\n"
+
+        except Exception as e:
+            yield f"Error during code execution: {str(e)}"
+
+
+
+

gemini_tools_defination.py

@@ -0,0 +1,109 @@
+from google.genai import types
+from google import genai
+from gemini_llm import GeminiLLM
+
+class GeminiToolDefination:
+    def __init__(self, geminillm: GeminiLLM, result=None):
+        self.geminillm = geminillm
+        self.result = result
+
+        self.gemini_thinking_declaration = {
+            "name": "GeminiThinking",
+            "description": (
+                "Use this tool when the user's input suggests they are looking for thoughtful reflection, brainstorming, "
+                "hypothetical reasoning, or deep analysis. This includes philosophical questions, complex scenarios, or tasks "
+                "where the agent must 'think' or 'reflect' to provide a structured or creative response. "
+                "When to use: if the user is asking 'what if', 'analyze', 'brainstorm', or 'explore possibilities'. "
+                "Avoid this tool for factual, time-sensitive, or technical queries—use search or code tools instead."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": (
+                            "Queries asking for reasoning or deep thought. "
+                            "Examples: 'What are some possible futures if humans colonize Mars?', "
+                            "'Can you explore the societal effects of AI on human creativity?', "
+                            "'Is ambition more helpful or harmful in life?'"
+                        )
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+
+        self.google_search_tool = {
+            "name": "GoogleSearchTool",
+            "description": (
+                "Use this tool when the user is asking for specific, real-time, or factual information that may be outside the model's knowledge. "
+                "This includes recent news, live events, product prices, names, or anything the model cannot confidently answer from training data alone. "
+                "When to use: if the model would otherwise respond with 'I'm not sure', 'As of my last update', or 'I cannot browse the web'. "
+                "Avoid this for reasoning or general knowledge that doesn't need live updates."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": (
+                            "Use for fact-seeking or current-event queries. "
+                            "Examples: 'What is the weather in Delhi today?', 'Latest iPhone 16 release date in India', "
+                            "'Who is the current CEO of Google?', 'How did the 2024 elections end?'"
+                        )
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+
+        self.gemini_code_execution_tool = {
+            "name": "GeminiCodeExecutionTool",
+            "description": (
+                "Use this tool when the user's prompt involves programming—writing, debugging, explaining, or executing code. "
+                "Only invoke this for well-scoped technical/code tasks that require functional accuracy or output simulation. "
+                "When to use: if the user asks for code generation, debugging, implementation, or syntax correction. "
+                "Avoid this for general tech explanations—those don't require execution."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": (
+                            "Programming-related prompts. "
+                            "Examples: 'Write a Python function to reverse a list', 'Fix this error in my code: ...', "
+                            "'What will this JavaScript function return?', 'Create a REST API in Flask'."
+                        )
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+
+        self.tools = types.Tool(function_declarations=[
+            self.gemini_thinking_declaration,
+            self.google_search_tool,
+            self.gemini_code_execution_tool
+        ])
+
+        self.config = types.GenerateContentConfig(tools=[self.tools])
+
+    def pick_the_tool(self, prompt_text: str):
+        contents = [
+            types.Content(
+                role="user",
+                parts=[types.Part(text=prompt_text)]
+            )
+        ]
+
+        try:
+            response = self.geminillm.client.models.generate_content(
+                model=self.geminillm.model_id,
+                config=self.config,
+                contents=contents
+            )
+            self.result = response
+            return self.result
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate response with tools: {str(e)}")

src/streamlit_app.py

@@ -1,40 +1,110 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+from google import genai
+from google.genai import types
+from gemini_tools_defination import GeminiToolDefination
+from gemini_llm import GeminiLLM
+from gemini_history import ConversationBuilder
+from gemini_tools import GeminiCodeExecutionTool, GeminiThinking, GoogleSearchTool
+from utils import get_typing_indicator_html
+from gemini_tool_selector import GeminiToolSelector
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+geminillm=GeminiLLM()
+geminitooldefination = GeminiToolDefination(geminillm)
+conversationbuilder = ConversationBuilder()
+geminitoolselector = GeminiToolSelector()
+client = geminillm.client
+
+if "chat" not in st.session_state:
+    st.session_state.chat = client.chats.create(model=geminillm.model_id, config=geminitooldefination.config)
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# default message
+if not st.session_state.messages:
+    with st.chat_message("assistant", avatar="images/ai.png"):
+        st.markdown("👋 **Hi! I can help you think, code, or search real-time info. Just ask!**")
+
+# Tool name map
+tool_mapping = {
+    "Auto": None,
+    "Think": "GeminiThinking",
+    "Search": "GoogleSearchTool",
+    "Code": "GeminiCodeExecutionTool"
+}
+
+# display chat messages from history at every rerun  
+for message in st.session_state.messages:
+    avatar_path = (
+        "images/person_15454011.png" if message["role"] == "user"
+        else "images/ai.png"
+    )
+    with st.chat_message(message["role"], avatar=avatar_path):
+        st.markdown(message["content"])
+
+if "selected_tool" not in st.session_state:
+    st.session_state.selected_tool = "Auto"
+
+st.sidebar.title("Tools")
+selected_tool = st.sidebar.selectbox(
+    "Choose a tool:",
+    options=list(tool_mapping.keys()),
+    index=list(tool_mapping.keys()).index(st.session_state.selected_tool),
+)
+
+# Update the session state with current selection
+st.session_state.selected_tool = selected_tool
+
+prompt = st.chat_input("What is up?")
+selected_tool_name = tool_mapping[st.session_state.selected_tool]
+
+
+if prompt:
+    try:
+        # show user message
+        with st.chat_message("user", avatar="images/person_15454011.png"):
+            st.markdown(prompt)
+        # Save user message
+        st.session_state.messages.append({"role": "user", "content": prompt})
+
+        # stream assistant response
+        full_response = ""
+        with st.chat_message("assistant", avatar="images/ai.png"):
+            response_stream = st.session_state.chat.send_message_stream(prompt)
+            response_placeholder = st.empty()
+            
+            if selected_tool_name:
+                tool_args = {"query": prompt}
+                full_response = geminitoolselector.handle_tool_response(selected_tool_name, tool_args, geminillm)
+                # need to add response in chat history
+                content_only_convo = conversationbuilder.build_with_content_only(full_response)
+                st.session_state.chat.get_history().extend(content_only_convo)
+
+            else:
+                for chunk in response_stream:
+                    if chunk.text is None:  # if response is None means a tool is hit
+                        tool_name = chunk.candidates[0].content.parts[0].function_call.name
+                        tool_args = chunk.candidates[0].content.parts[0].function_call.args
+
+                        response_placeholder = st.empty()
+                        
+                        # handle tool response
+                        streamed_output = geminitoolselector.handle_tool_response(tool_name, tool_args, geminillm)
+
+                        full_response = streamed_output  
+                        
+                        # IMP..... add the response in the chathistory can see by st.session_state.chat.get_history() see complete history you will see the content is missing there and u can also more then one conttent
+                        content_only_convo = conversationbuilder.build_with_content_only(full_response)
+                        st.session_state.chat.get_history().extend(content_only_convo)
+                        
+                        # st.markdown(st.session_state.chat.get_history())  ## for reference how chat history is working
+                    else:
+                        full_response += chunk.text
+                        response_placeholder.markdown(full_response + "")  # stream effect
+
+        # save assistant message (load all the messages to show chat type view in UI )
+        st.session_state.messages.append({"role": "assistant", "content": full_response})
+        # print(st.session_state.chat.get_history())  ## for reference how chat history is working
+
+    except Exception as e:
+        st.error(f"An error occurred: {e}")

system_prompt.py

@@ -0,0 +1,47 @@
+system_prompt = """
+You are an intelligent assistant integrated with multiple reasoning and execution tools. Your primary task is to analyze the user's intent and route their query to the most appropriate internal tool for accurate and efficient assistance.
+
+Available Tools:
+
+1. GeminiThinking (GeminiThinking)
+   - Use this when the user is seeking thoughtful reflection, brainstorming, speculative reasoning, or deeper philosophical analysis.
+   - Examples:
+     - "What if humans could upload consciousness?"
+     - "Brainstorm startup ideas using AI in agriculture"
+     - "Is ambition more harmful or helpful in life?"
+
+2. Google Search Tool (GoogleSearchTool)
+   - Use this when the user asks for real-time, fact-based, or current information beyond your knowledge cut-off.
+   - Examples:
+     - "What’s the weather in Delhi today?"
+     - "When is the next iPhone launching in India?"
+     - "Who won the 2024 Lok Sabha elections?"
+
+3. Gemini Code Execution Tool (GeminiCodeExecutionTool)
+   - Use this when the user asks for programming help such as code generation, debugging, or technical implementations.
+   - Examples:
+     - "Write Python code to find prime numbers"
+     - "Fix this error: IndexError in my loop"
+     - "Explain how to use decorators in Python"
+
+Response Guidelines:
+
+- Format responses in Markdown for clarity.
+- Provide a clear, structured answer before invoking any tool.
+- Be concise, respectful, and professional in tone.
+- If necessary data for a tool is missing (e.g., vague question or unclear intent), ask the user for clarification before invoking any tool.
+
+Do NOT invoke any tool if:
+
+- The user's query is off-topic, conversational, or requires general advice not requiring execution or deep reasoning.
+- The query is too vague or lacks clarity. Ask for more information first.
+
+Examples:
+
+- "Tell me about AI impact on jobs in future" → Use (GeminiThinking)
+- "What's the price of Bitcoin now?" → Use (GoogleSearchTool)
+- "Create a Flask API for user login" → Use (GeminiCodeExecutionTool)
+- "What is recursion?" → Do NOT invoke any tool. Just explain it.
+
+Only invoke a tool if the user's intent clearly aligns with a tool’s purpose and all needed inputs are available.
+"""

utils.py

@@ -0,0 +1,38 @@
+def get_typing_indicator_html(label_text="Thinking"):
+    return f"""
+    <div class="thinking-wrap">
+      <span class="label">{label_text}</span>
+      <span class="dot dot1"></span>
+      <span class="dot dot2"></span>
+      <span class="dot dot3"></span>
+    </div>
+
+    <style>
+    .thinking-wrap {{
+      font-family: 'Arial', sans-serif;
+      color: #666;
+      font-size: 16px;
+      display: flex;
+      align-items: center;
+      gap: 4px;
+      padding: 6px 0;
+    }}
+    .label {{
+      font-weight: bold;
+    }}
+    .dot {{
+      width: 6px;
+      height: 6px;
+      background: #666;
+      border-radius: 50%;
+      animation: blink 1s infinite ease-in-out;
+    }}
+    .dot2 {{ animation-delay: 0.2s; }}
+    .dot3 {{ animation-delay: 0.4s; }}
+
+    @keyframes blink {{
+      0%, 100% {{ opacity: 0.2; transform: translateY(0); }}
+      50% {{ opacity: 1; transform: translateY(-4px); }}
+    }}
+    </style>
+    """