Upload folder using huggingface_hub

.env.tpl

@@ -0,0 +1,10 @@
+# right now we use Google search API
+SEARCH_API_KEY=your-google-search-api-key
+SEARCH_PROJECT_KEY=your-google-cx-key
+
+# right now we use OpenAI API
+LLM_API_KEY=your-openai-api-key
+
+# Run and share Gradio UI
+RUN_GRADIO_UI=False
+SHARE_GRADIO_UI=False

.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.gradio

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 pengfeng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,164 @@
 ---
-title: Ask2.py
-emoji: 👀
-colorFrom: yellow
-colorTo: gray
+title: ask2.py
+app_file: ask.py
 sdk: gradio
-sdk_version: 5.4.0
-app_file: app.py
-pinned: false
+sdk_version: 5.3.0
 ---
+# ask.py
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+[![License](https://img.shields.io/github/license/pengfeng/ask.py)](LICENSE)
+
+A single Python program to implement the search-extract-summarize flow, similar to AI search
+engines such as Perplexity.
+
+> [!NOTE]
+> Our main goal is to illustrate the basic concepts of AI search engines with the raw constructs.
+> Performance or scalability is not in the scope of this program.
+
+> [UPDATE]
+>
+> - 2024-10-28: add extract function as a new output mode
+> - 2024-10-25: add hybrid search demo using DuckDB full-text search
+> - 2024-10-22: add GradIO integation
+> - 2024-10-21: use DuckDB for the vector search and use API for embedding
+> - 2024-10-20: allow to specify a list of input urls
+> - 2024-10-18: output-language and output-length parameters for LLM
+> - 2024-10-18: date-restrict and target-site parameters for seach
+
+## The search-extract-summarize flow
+
+Given a query, the program will
+
+- search Google for the top 10 web pages
+- crawl and scape the pages for their text content
+- chunk the text content into chunks and save them into a vectordb
+- perform a vector search with the query and find the top 10 matched chunks
+- [Optional] search using full-text search and combine the results with the vector search
+- [Optional] use a reranker to re-rank the top chunks
+- use the top chunks as the context to ask an LLM to generate the answer
+- output the answer with the references
+
+Of course this flow is a very simplified version of the real AI search engines, but it is a good
+starting point to understand the basic concepts.
+
+One benefit is that we can manipulate the search function and output format.
+
+For example, we can:
+
+- search with date-restrict to only retrieve the latest information.
+- search within a target-site to only create the answer from the contents from it.
+- ask LLM to use a specific language to answer the question.
+- ask LLM to answer with a specific length.
+- crawl a specific list of urls and answer based on those contents only.
+
+## Quick start
+
+```bash
+# recommend to use Python 3.10 or later and use venv or conda to create a virtual environment
+pip install -r requirements.txt
+
+# modify .env file to set the API keys or export them as environment variables as below
+
+# right now we use Google search API
+export SEARCH_API_KEY="your-google-search-api-key"
+export SEARCH_PROJECT_KEY="your-google-cx-key"
+
+# right now we use OpenAI API
+export LLM_API_KEY="your-openai-api-key"
+
+# run the program
+python ask.py -q "What is an LLM agent?"
+
+# we can specify more parameters to control the behavior such as date_restrict and target_site
+python ask.py --help
+Usage: ask.py [OPTIONS]
+
+  Search web for the query and summarize the results.
+
+Options:
+  -q, --query TEXT                Query to search
+  -o, --output-mode [answer|extract]
+                                  Output mode for the answer, default is a
+                                  simple answer
+  -d, --date-restrict INTEGER     Restrict search results to a specific date
+                                  range, default is no restriction
+  -s, --target-site TEXT          Restrict search results to a specific site,
+                                  default is no restriction
+  --output-language TEXT          Output language for the answer
+  --output-length INTEGER         Output length for the answer
+  --url-list-file TEXT            Instead of doing web search, scrape the
+                                  target URL list and answer the query based
+                                  on the content
+  --extract-schema-file TEXT      Pydantic schema for the extract mode
+  -m, --inference-model-name TEXT
+                                  Model name to use for inference
+  --hybrid-search                 Use hybrid search mode with both vector
+                                  search and full-text search
+  --web-ui                        Launch the web interface
+  -l, --log-level [DEBUG|INFO|WARNING|ERROR]
+                                  Set the logging level  [default: INFO]
+  --help                          Show this message and exit.
+```
+
+## Libraries and APIs used
+
+- [Google Search API](https://developers.google.com/custom-search/v1/overview)
+- [OpenAI API](https://beta.openai.com/docs/api-reference/completions/create)
+- [Jinja2](https://jinja.palletsprojects.com/en/3.0.x/)
+- [bs4](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)
+- [DuckDB](https://github.com/duckdb/duckdb)
+- [GradIO](https://github.com/gradio-app/gradio)
+
+## GradIO Deployment
+
+> [!NOTE]
+> Original GradIO app-sharing document [here](https://www.gradio.app/guides/sharing-your-app).
+> We have a running example [here](https://huggingface.co/spaces/leettools/AskPy).
+
+### Quick test and sharing
+
+You can run the program with `--web-ui` option to launch the web interface and check it locally.
+
+```bash
+python ask.py --web-ui
+* Running on local URL:  http://127.0.0.1:7860
+
+# you can also specify SHARE_GRADIO_UI to run a sharable UI through GradIO
+export SHARE_GRADIO_UI=True
+python ask.py --web-ui
+* Running on local URL:  http://127.0.0.1:7860
+* Running on public URL: https://77c277af0330326587.gradio.live
+```
+
+### To share a more permanent link using HuggingFace Space
+
+- First, you need to [create a free HuggingFace account](https://huggingface.co/welcome).
+- Then in your [settings/token page](https://huggingface.co/settings/tokens), create a new token with Write permissions.
+- In your terminal, run the following commands in you app directory to deploy your program to
+  HuggingFace Space:
+
+```bash
+pip install gradio
+gradio deploy
+# You will be prompted to enter your HuggingFace token
+```
+
+After the deployment, the app should be on https://huggingface.co/spaces/your_username/AskPy
+
+Now you need to go to the settings page to add some variables and secrets https://huggingface.co/spaces/your_username/AskPy/settings
+
+- variable: RUN_GRADIO_UI=True
+- variable: SHARE_GRADIO_UI=True
+- secret: SEARCH_API_KEY=<YOUR_SEARCH_API_KEY>
+- secret: SEARCH_PROJECT_KEY=<YOUR_SEARCH_PROJECT_KEY>
+- sercet: LLM_API_KEY=<YOUR_LLM_API_KEY>
+
+Now you can use the HuggingFace space app to run your queries.
+
+![image](https://github.com/user-attachments/assets/0483e6a2-75d7-4fbd-813f-bfa13839c836)
+
+## Use Cases
+
+- [Search like Perplexity](demos/search_and_answer.md)
+- [Only use the latest information from a specific site](demos/search_on_site_and_date.md)
+- [Extract information from web search results](demos/search_and_extract.md)

ask.py

@@ -0,0 +1,1020 @@
+import csv
+import io
+import json
+import logging
+import os
+import queue
+import urllib.parse
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from enum import Enum
+from functools import partial
+from queue import Queue
+from typing import Any, Dict, Generator, List, Optional, Tuple, TypeVar
+
+import click
+import duckdb
+import gradio as gr
+import requests
+from bs4 import BeautifulSoup
+from dotenv import load_dotenv
+from jinja2 import BaseLoader, Environment
+from openai import OpenAI
+from pydantic import BaseModel, create_model
+
+TypeVar_BaseModel = TypeVar("TypeVar_BaseModel", bound=BaseModel)
+
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+default_env_file = os.path.abspath(os.path.join(script_dir, ".env"))
+
+
+class OutputMode(str, Enum):
+    answer = "answer"
+    extract = "extract"
+
+
+class AskSettings(BaseModel):
+    date_restrict: int
+    target_site: str
+    output_language: str
+    output_length: int
+    url_list: List[str]
+    inference_model_name: str
+    hybrid_search: bool
+    output_mode: OutputMode
+    extract_schema_str: str
+
+
+def _get_logger(log_level: str) -> logging.Logger:
+    logger = logging.getLogger(__name__)
+    logger.setLevel(log_level)
+    if len(logger.handlers) > 0:
+        return logger
+
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger
+
+
+def _read_url_list(url_list_file: str) -> List[str]:
+    if not url_list_file:
+        return []
+
+    with open(url_list_file, "r") as f:
+        links = f.readlines()
+    url_list = [
+        link.strip()
+        for link in links
+        if link.strip() != "" and not link.startswith("#")
+    ]
+    return url_list
+
+
+def _read_extract_schema_str(extract_schema_file: str) -> str:
+    if not extract_schema_file:
+        return ""
+
+    with open(extract_schema_file, "r") as f:
+        schema_str = f.read()
+    return schema_str
+
+
+def _output_csv(result_dict: Dict[str, List[BaseModel]], key_name: str) -> str:
+    # generate the CSV content from a Dict of URL and list of extracted items
+    output = io.StringIO()
+    csv_writer = None
+    for src_url, items in result_dict.items():
+        for item in items:
+            value_dict = item.model_dump()
+            item_with_url = {**value_dict, key_name: src_url}
+
+            if csv_writer is None:
+                headers = list(value_dict.keys()) + [key_name]
+                csv_writer = csv.DictWriter(output, fieldnames=headers)
+                csv_writer.writeheader()
+
+            csv_writer.writerow(item_with_url)
+
+    csv_content = output.getvalue()
+    output.close()
+    return csv_content
+
+
+class Ask:
+
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        self.read_env_variables()
+
+        if logger is not None:
+            self.logger = logger
+        else:
+            self.logger = _get_logger("INFO")
+
+        self.db_con = duckdb.connect(":memory:")
+
+        self.db_con.install_extension("vss")
+        self.db_con.load_extension("vss")
+        self.db_con.install_extension("fts")
+        self.db_con.load_extension("fts")
+        self.db_con.sql("CREATE SEQUENCE seq_docid START 1000")
+
+        self.session = requests.Session()
+        user_agent: str = (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0"
+        )
+        self.session.headers.update({"User-Agent": user_agent})
+
+    def read_env_variables(self) -> None:
+        err_msg = ""
+
+        self.search_api_key = os.environ.get("SEARCH_API_KEY")
+        if self.search_api_key is None:
+            err_msg += "SEARCH_API_KEY env variable not set.\n"
+        self.search_project_id = os.environ.get("SEARCH_PROJECT_KEY")
+        if self.search_project_id is None:
+            err_msg += "SEARCH_PROJECT_KEY env variable not set.\n"
+        self.llm_api_key = os.environ.get("LLM_API_KEY")
+        if self.llm_api_key is None:
+            err_msg += "LLM_API_KEY env variable not set.\n"
+
+        if err_msg != "":
+            raise Exception(f"\n{err_msg}\n")
+
+        self.llm_base_url = os.environ.get("LLM_BASE_URL")
+        if self.llm_base_url is None:
+            self.llm_base_url = "https://api.openai.com/v1"
+
+        self.embedding_model = os.environ.get("EMBEDDING_MODEL")
+        self.embedding_dimensions = os.environ.get("EMBEDDING_DIMENSIONS")
+
+        if self.embedding_model is None or self.embedding_dimensions is None:
+            self.embedding_model = "text-embedding-3-small"
+            self.embedding_dimensions = 1536
+
+    def search_web(self, query: str, settings: AskSettings) -> List[str]:
+        escaped_query = urllib.parse.quote(query)
+        url_base = (
+            f"https://www.googleapis.com/customsearch/v1?key={self.search_api_key}"
+            f"&cx={self.search_project_id}&q={escaped_query}"
+        )
+        url_paras = f"&safe=active"
+        if settings.date_restrict > 0:
+            url_paras += f"&dateRestrict={settings.date_restrict}"
+        if settings.target_site:
+            url_paras += f"&siteSearch={settings.target_site}&siteSearchFilter=i"
+        url = f"{url_base}{url_paras}"
+
+        self.logger.debug(f"Searching for query: {query}")
+
+        resp = requests.get(url)
+
+        if resp is None:
+            raise Exception("No response from search API")
+
+        search_results_dict = json.loads(resp.text)
+        if "error" in search_results_dict:
+            raise Exception(
+                f"Error in search API response: {search_results_dict['error']}"
+            )
+
+        if "searchInformation" not in search_results_dict:
+            raise Exception(
+                f"No search information in search API response: {resp.text}"
+            )
+
+        total_results = search_results_dict["searchInformation"].get("totalResults", 0)
+        if total_results == 0:
+            self.logger.warning(f"No results found for query: {query}")
+            return []
+
+        results = search_results_dict.get("items", [])
+        if results is None or len(results) == 0:
+            self.logger.warning(f"No result items in the response for query: {query}")
+            return []
+
+        found_links = []
+        for result in results:
+            link = result.get("link", None)
+            if link is None or link == "":
+                self.logger.warning(f"Search result link missing: {result}")
+                continue
+            found_links.append(link)
+        return found_links
+
+    def _scape_url(self, url: str) -> Tuple[str, str]:
+        self.logger.info(f"Scraping {url} ...")
+        try:
+            response = self.session.get(url, timeout=10)
+            soup = BeautifulSoup(response.content, "lxml", from_encoding="utf-8")
+
+            body_tag = soup.body
+            if body_tag:
+                body_text = body_tag.get_text()
+                body_text = " ".join(body_text.split()).strip()
+                self.logger.debug(f"Scraped {url}: {body_text}...")
+                if len(body_text) > 100:
+                    self.logger.info(
+                        f"✅ Successfully scraped {url} with length: {len(body_text)}"
+                    )
+                    return url, body_text
+                else:
+                    self.logger.warning(
+                        f"Body text too short for url: {url}, length: {len(body_text)}"
+                    )
+                    return url, ""
+            else:
+                self.logger.warning(f"No body tag found in the response for url: {url}")
+                return url, ""
+        except Exception as e:
+            self.logger.error(f"Scraping error {url}: {e}")
+            return url, ""
+
+    def scrape_urls(self, urls: List[str]) -> Dict[str, str]:
+        # the key is the url and the value is the body text
+        scrape_results: Dict[str, str] = {}
+
+        partial_scrape = partial(self._scape_url)
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            results = executor.map(partial_scrape, urls)
+
+        for url, body_text in results:
+            if body_text != "":
+                scrape_results[url] = body_text
+
+        return scrape_results
+
+    def chunk_results(
+        self, scrape_results: Dict[str, str], size: int, overlap: int
+    ) -> Dict[str, List[str]]:
+        chunking_results: Dict[str, List[str]] = {}
+        for url, text in scrape_results.items():
+            chunks = []
+            for pos in range(0, len(text), size - overlap):
+                chunks.append(text[pos : pos + size])
+            chunking_results[url] = chunks
+        return chunking_results
+
+    def get_embedding(self, client: OpenAI, texts: List[str]) -> List[List[float]]:
+        if len(texts) == 0:
+            return []
+
+        response = client.embeddings.create(input=texts, model=self.embedding_model)
+        embeddings = []
+        for i in range(len(response.data)):
+            embeddings.append(response.data[i].embedding)
+        return embeddings
+
+    def batch_get_embedding(
+        self, client: OpenAI, chunk_batch: Tuple[str, List[str]]
+    ) -> Tuple[Tuple[str, List[str]], List[List[float]]]:
+        """
+        Return the chunk_batch as well as the embeddings for each chunk so that
+        we can aggregate them and save them to the database together.
+
+        Args:
+        - client: OpenAI client
+        - chunk_batch: Tuple of URL and list of chunks scraped from the URL
+
+        Returns:
+        - Tuple of chunk_bach and list of result embeddings
+        """
+        texts = chunk_batch[1]
+        embeddings = self.get_embedding(client, texts)
+        return chunk_batch, embeddings
+
+    def _create_table(self) -> str:
+        # Simple ways to get a unique table name
+        timestamp = datetime.now().strftime("%Y_%m_%d_%H_%M_%S_%f")
+        table_name = f"document_chunks_{timestamp}"
+
+        self.db_con.execute(
+            f"""
+CREATE TABLE {table_name} (
+    doc_id INTEGER PRIMARY KEY DEFAULT nextval('seq_docid'),
+    url TEXT,
+    chunk TEXT,
+    vec FLOAT[{self.embedding_dimensions}]
+);
+"""
+        )
+        return table_name
+
+    def save_chunks_to_db(self, chunking_results: Dict[str, List[str]]) -> str:
+        """
+        The key of chunking_results is the URL and the value is the list of chunks.
+        """
+        client = self._get_api_client()
+        embed_batch_size = 50
+        query_batch_size = 100
+        insert_data = []
+
+        table_name = self._create_table()
+
+        batches: List[Tuple[str, List[str]]] = []
+        for url, list_chunks in chunking_results.items():
+            for i in range(0, len(list_chunks), embed_batch_size):
+                list_chunks = list_chunks[i : i + embed_batch_size]
+                batches.append((url, list_chunks))
+
+        self.logger.info(f"Embedding {len(batches)} batches of chunks ...")
+        partial_get_embedding = partial(self.batch_get_embedding, client)
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            all_embeddings = executor.map(partial_get_embedding, batches)
+        self.logger.info(f"✅ Finished embedding.")
+
+        # we batch the insert data to speed up the insertion operation
+        # although the DuckDB doc says executeMany is optimized for batch insert
+        # but we found that it is faster to batch the insert data and run a single insert
+        for chunk_batch, embeddings in all_embeddings:
+            url = chunk_batch[0]
+            list_chunks = chunk_batch[1]
+            insert_data.extend(
+                [
+                    (url.replace("'", " "), chunk.replace("'", " "), embedding)
+                    for chunk, embedding in zip(list_chunks, embeddings)
+                ]
+            )
+
+        for i in range(0, len(insert_data), query_batch_size):
+            value_str = ", ".join(
+                [
+                    f"('{url}', '{chunk}', {embedding})"
+                    for url, chunk, embedding in insert_data[i : i + embed_batch_size]
+                ]
+            )
+            query = f"""
+            INSERT INTO {table_name} (url, chunk, vec) VALUES {value_str};
+            """
+            self.db_con.execute(query)
+
+        self.db_con.execute(
+            f"""
+                CREATE INDEX {table_name}_cos_idx ON {table_name} USING HNSW (vec)
+                WITH (metric = 'cosine');
+            """
+        )
+        self.logger.info(f"✅ Created the vector index ...")
+        self.db_con.execute(
+            f"""
+                PRAGMA create_fts_index(
+                {table_name}, 'doc_id', 'chunk'
+                );    
+            """
+        )
+        self.logger.info(f"✅ Created the full text search index ...")
+        return table_name
+
+    def vector_search(
+        self, table_name: str, query: str, settings: AskSettings
+    ) -> List[Dict[str, Any]]:
+        """
+        The return value is a list of {url: str, chunk: str} records.
+        In a real world, we will define a class of Chunk to have more metadata such as offsets.
+        """
+        client = self._get_api_client()
+        embeddings = self.get_embedding(client, [query])[0]
+
+        query_result: duckdb.DuckDBPyRelation = self.db_con.sql(
+            f"""
+            SELECT * FROM {table_name} 
+            ORDER BY array_distance(vec, {embeddings}::FLOAT[{self.embedding_dimensions}]) 
+            LIMIT 10;         
+        """
+        )
+
+        self.logger.debug(query_result)
+
+        # use a dict to remove duplicates from vector search and full-text search
+        matched_chunks_dict = {}
+        for vec_result in query_result.fetchall():
+            doc_id = vec_result[0]
+            result_record = {
+                "url": vec_result[1],
+                "chunk": vec_result[2],
+            }
+            matched_chunks_dict[doc_id] = result_record
+
+        if settings.hybrid_search:
+            self.logger.info("Running full-text search ...")
+
+            self.db_con.execute(
+                f"""
+                PREPARE fts_query AS (
+                    WITH scored_docs AS (
+                        SELECT *, fts_main_{table_name}.match_bm25(
+                            doc_id, ?, fields := 'chunk'
+                        ) AS score FROM {table_name})
+                    SELECT doc_id, url, chunk, score
+                    FROM scored_docs
+                    WHERE score IS NOT NULL
+                    ORDER BY score DESC
+                    LIMIT 10)
+                """
+            )
+            self.db_con.execute("PRAGMA threads=4")
+
+            # You can run more complex query rewrite methods here
+            # usually: stemming, stop words, etc.
+            escaped_query = query.replace("'", " ")
+            fts_result: duckdb.DuckDBPyRelation = self.db_con.execute(
+                f"EXECUTE fts_query('{escaped_query}')"
+            )
+
+            index = 0
+            for fts_record in fts_result.fetchall():
+                index += 1
+                self.logger.debug(f"The full text search record #{index}: {fts_record}")
+                doc_id = fts_record[0]
+                result_record = {
+                    "url": fts_record[1],
+                    "chunk": fts_record[2],
+                }
+
+                # You can configure the score threashold and top-k
+                if fts_record[3] > 1:
+                    matched_chunks_dict[doc_id] = result_record
+                else:
+                    break
+
+                if index >= 10:
+                    break
+
+        return matched_chunks_dict.values()
+
+    def _get_api_client(self) -> OpenAI:
+        return OpenAI(api_key=self.llm_api_key, base_url=self.llm_base_url)
+
+    def _render_template(self, template_str: str, variables: Dict[str, Any]) -> str:
+        env = Environment(loader=BaseLoader(), autoescape=False)
+        template = env.from_string(template_str)
+        return template.render(variables)
+
+    def _get_target_class(self, extract_schema_str: str) -> TypeVar_BaseModel:
+        local_namespace = {"BaseModel": BaseModel}
+        exec(extract_schema_str, local_namespace, local_namespace)
+        for key, value in local_namespace.items():
+            if key == "__builtins__":
+                continue
+            if key == "BaseModel":
+                continue
+            if isinstance(value, type):
+                if issubclass(value, BaseModel):
+                    return value
+        raise Exception("No Pydantic schema found in the extract schema str.")
+
+    def run_inference(
+        self,
+        query: str,
+        matched_chunks: List[Dict[str, Any]],
+        settings: AskSettings,
+    ) -> str:
+        system_prompt = (
+            "You are an expert summarizing the answers based on the provided contents."
+        )
+        user_promt_template = """
+Given the context as a sequence of references with a reference id in the 
+format of a leading [x], please answer the following question using {{ language }}:
+
+{{ query }}
+
+In the answer, use format [1], [2], ..., [n] in line where the reference is used. 
+For example, "According to the research from Google[3], ...".
+
+Please create the answer strictly related to the context. If the context has no
+information about the query, please write "No related information found in the context."
+using {{ language }}.
+
+{{ length_instructions }}
+
+Here is the context:
+{{ context }}
+"""
+        context = ""
+        for i, chunk in enumerate(matched_chunks):
+            context += f"[{i+1}] {chunk['chunk']}\n"
+
+        if not settings.output_length:
+            length_instructions = ""
+        else:
+            length_instructions = (
+                f"Please provide the answer in { settings.output_length } words."
+            )
+
+        user_prompt = self._render_template(
+            user_promt_template,
+            {
+                "query": query,
+                "context": context,
+                "language": settings.output_language,
+                "length_instructions": length_instructions,
+            },
+        )
+
+        self.logger.debug(
+            f"Running inference with model: {settings.inference_model_name}"
+        )
+        self.logger.debug(f"Final user prompt: {user_prompt}")
+
+        api_client = self._get_api_client()
+        completion = api_client.chat.completions.create(
+            model=settings.inference_model_name,
+            messages=[
+                {
+                    "role": "system",
+                    "content": system_prompt,
+                },
+                {
+                    "role": "user",
+                    "content": user_prompt,
+                },
+            ],
+        )
+        if completion is None:
+            raise Exception("No completion from the API")
+
+        response_str = completion.choices[0].message.content
+        return response_str
+
+    def run_extract(
+        self,
+        query: str,
+        extract_schema_str: str,
+        target_content: str,
+        settings: AskSettings,
+    ) -> List[TypeVar_BaseModel]:
+        target_class = self._get_target_class(extract_schema_str)
+        system_prompt = (
+            "You are an expert of extract structual information from the document."
+        )
+        user_promt_template = """
+Given the provided content, if it contains information about {{ query }}, please extract the
+list of structured data items as defined in the following Pydantic schema:
+
+{{ extract_schema_str }}
+
+Below is the provided content:
+{{ content }}
+"""
+        user_prompt = self._render_template(
+            user_promt_template,
+            {
+                "query": query,
+                "content": target_content,
+                "extract_schema_str": extract_schema_str,
+            },
+        )
+
+        self.logger.debug(
+            f"Running extraction with model: {settings.inference_model_name}"
+        )
+        self.logger.debug(f"Final user prompt: {user_prompt}")
+
+        class_name = target_class.__name__
+        list_class_name = f"{class_name}_list"
+        response_pydantic_model = create_model(
+            list_class_name,
+            items=(List[target_class], ...),
+        )
+
+        api_client = self._get_api_client()
+        completion = api_client.beta.chat.completions.parse(
+            model=settings.inference_model_name,
+            messages=[
+                {
+                    "role": "system",
+                    "content": system_prompt,
+                },
+                {
+                    "role": "user",
+                    "content": user_prompt,
+                },
+            ],
+            response_format=response_pydantic_model,
+        )
+        if completion is None:
+            raise Exception("No completion from the API")
+
+        message = completion.choices[0].message
+        if message.refusal:
+            raise Exception(
+                f"Refused to extract information from the document: {message.refusal}."
+            )
+
+        extract_result = message.parsed
+        return extract_result.items
+
+    def run_query_gradio(
+        self,
+        query: str,
+        date_restrict: int,
+        target_site: str,
+        output_language: str,
+        output_length: int,
+        url_list_str: str,
+        inference_model_name: str,
+        hybrid_search: bool,
+        output_mode_str: str,
+        extract_schema_str: str,
+    ) -> Generator[Tuple[str, str], None, Tuple[str, str]]:
+        logger = self.logger
+        log_queue = Queue()
+
+        if url_list_str:
+            url_list = url_list_str.split("\n")
+        else:
+            url_list = []
+
+        settings = AskSettings(
+            date_restrict=date_restrict,
+            target_site=target_site,
+            output_language=output_language,
+            output_length=output_length,
+            url_list=url_list,
+            inference_model_name=inference_model_name,
+            hybrid_search=hybrid_search,
+            output_mode=OutputMode(output_mode_str),
+            extract_schema_str=extract_schema_str,
+        )
+
+        queue_handler = logging.Handler()
+        formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+        queue_handler.emit = lambda record: log_queue.put(formatter.format(record))
+        logger.addHandler(queue_handler)
+
+        def update_logs():
+            logs = []
+            while True:
+                try:
+                    log = log_queue.get_nowait()
+                    logs.append(log)
+                except queue.Empty:
+                    break
+            return "\n".join(logs)
+
+        # wrap the process in a generator to yield the logs to integrate with GradIO
+        def process_with_logs():
+            if len(settings.url_list) > 0:
+                links = settings.url_list
+            else:
+                logger.info("Searching the web ...")
+                yield "", update_logs()
+                links = self.search_web(query, settings)
+                logger.info(f"✅ Found {len(links)} links for query: {query}")
+                for i, link in enumerate(links):
+                    logger.debug(f"{i+1}. {link}")
+                yield "", update_logs()
+
+            logger.info("Scraping the URLs ...")
+            yield "", update_logs()
+            scrape_results = self.scrape_urls(links)
+            logger.info(f"✅ Scraped {len(scrape_results)} URLs.")
+            yield "", update_logs()
+
+            if settings.output_mode == OutputMode.answer:
+                logger.info("Chunking the text ...")
+                yield "", update_logs()
+                chunking_results = self.chunk_results(scrape_results, 1000, 100)
+                total_chunks = 0
+                for url, chunks in chunking_results.items():
+                    logger.debug(f"URL: {url}")
+                    total_chunks += len(chunks)
+                    for i, chunk in enumerate(chunks):
+                        logger.debug(f"Chunk {i+1}: {chunk}")
+                logger.info(f"✅ Generated {total_chunks} chunks ...")
+                yield "", update_logs()
+
+                logger.info(f"Saving {total_chunks} chunks to DB ...")
+                yield "", update_logs()
+                table_name = self.save_chunks_to_db(chunking_results)
+                logger.info(f"✅ Successfully embedded and saved chunks to DB.")
+                yield "", update_logs()
+
+                logger.info("Querying the vector DB to get context ...")
+                matched_chunks = self.vector_search(table_name, query, settings)
+                for i, result in enumerate(matched_chunks):
+                    logger.debug(f"{i+1}. {result}")
+                logger.info(f"✅ Got {len(matched_chunks)} matched chunks.")
+                yield "", update_logs()
+
+                logger.info("Running inference with context ...")
+                yield "", update_logs()
+                answer = self.run_inference(
+                    query=query,
+                    matched_chunks=matched_chunks,
+                    settings=settings,
+                )
+                logger.info("✅ Finished inference API call.")
+                logger.info("Generating output ...")
+                yield "", update_logs()
+
+                answer = f"# Answer\n\n{answer}\n"
+                references = "\n".join(
+                    [
+                        f"[{i+1}] {result['url']}"
+                        for i, result in enumerate(matched_chunks)
+                    ]
+                )
+                yield f"{answer}\n\n# References\n\n{references}", update_logs()
+            elif settings.output_mode == OutputMode.extract:
+                logger.info("Extracting structured data ...")
+                yield "", update_logs()
+
+                aggregated_output = {}
+                for url, text in scrape_results.items():
+                    items = self.run_extract(
+                        query=query,
+                        extract_schema_str=extract_schema_str,
+                        target_content=text,
+                        settings=settings,
+                    )
+                    self.logger.info(
+                        f"✅ Finished inference API call. Extracted {len(items)} items from {url}."
+                    )
+                    yield "", update_logs()
+
+                    self.logger.debug(items)
+                    aggregated_output[url] = items
+
+                logger.info("✅ Finished extraction from all urls.")
+                logger.info("Generating output ...")
+                yield "", update_logs()
+                answer = _output_csv(aggregated_output, "SourceURL")
+                yield f"{answer}", update_logs()
+            else:
+                raise Exception(f"Invalid output mode: {settings.output_mode}")
+
+        logs = ""
+        final_result = ""
+
+        try:
+            for result, log_update in process_with_logs():
+                logs += log_update + "\n"
+                final_result = result
+                yield final_result, logs
+        finally:
+            logger.removeHandler(queue_handler)
+
+        return final_result, logs
+
+    def run_query(
+        self,
+        query: str,
+        settings: AskSettings,
+    ) -> str:
+        url_list_str = "\n".join(settings.url_list)
+
+        for result, logs in self.run_query_gradio(
+            query=query,
+            date_restrict=settings.date_restrict,
+            target_site=settings.target_site,
+            output_language=settings.output_language,
+            output_length=settings.output_length,
+            url_list_str=url_list_str,
+            inference_model_name=settings.inference_model_name,
+            hybrid_search=settings.hybrid_search,
+            output_mode_str=settings.output_mode,
+            extract_schema_str=settings.extract_schema_str,
+        ):
+            final_result = result
+        return final_result
+
+
+def launch_gradio(
+    query: str,
+    init_settings: AskSettings,
+    share_ui: bool,
+    logger: logging.Logger,
+) -> None:
+    ask = Ask(logger=logger)
+
+    def toggle_schema_textbox(option):
+        if option == "extract":
+            return gr.update(visible=True)
+        else:
+            return gr.update(visible=False)
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# Ask.py - Web Search-Extract-Summarize")
+        gr.Markdown(
+            "Search the web with the query and summarize the results. Source code: https://github.com/pengfeng/ask.py"
+        )
+
+        with gr.Row():
+            with gr.Column():
+
+                query_input = gr.Textbox(label="Query", value=query)
+                output_mode_input = gr.Radio(
+                    label="Output Mode [answer: simple answer, extract: get structured data]",
+                    choices=["answer", "extract"],
+                    value=init_settings.output_mode,
+                )
+                extract_schema_input = gr.Textbox(
+                    label="Extract Pydantic Schema",
+                    visible=(init_settings.output_mode == "extract"),
+                    value=init_settings.extract_schema_str,
+                    lines=5,
+                    max_lines=20,
+                )
+                output_mode_input.change(
+                    fn=toggle_schema_textbox,
+                    inputs=output_mode_input,
+                    outputs=extract_schema_input,
+                )
+                date_restrict_input = gr.Number(
+                    label="Date Restrict (Optional) [0 or empty means no date limit.]",
+                    value=init_settings.date_restrict,
+                )
+                target_site_input = gr.Textbox(
+                    label="Target Sites (Optional) [Empty means searching the whole web.]",
+                    value=init_settings.target_site,
+                )
+                output_language_input = gr.Textbox(
+                    label="Output Language (Optional) [Default is English.]",
+                    value=init_settings.output_language,
+                )
+                output_length_input = gr.Number(
+                    label="Output Length in words (Optional) [Default is automatically decided by LLM.]",
+                    value=init_settings.output_length,
+                )
+                url_list_input = gr.Textbox(
+                    label="URL List (Optional) [When specified, scrape the urls instead of searching the web.]",
+                    lines=5,
+                    max_lines=20,
+                    value="\n".join(init_settings.url_list),
+                )
+
+                with gr.Accordion("More Options", open=False):
+                    hybrid_search_input = gr.Checkbox(
+                        label="Hybrid Search [Use both vector search and full-text search.]",
+                        value=init_settings.hybrid_search,
+                    )
+                    inference_model_name_input = gr.Textbox(
+                        label="Inference Model Name",
+                        value=init_settings.inference_model_name,
+                    )
+
+                submit_button = gr.Button("Submit")
+
+            with gr.Column():
+                answer_output = gr.Textbox(label="Answer")
+                logs_output = gr.Textbox(label="Logs", lines=10)
+
+        submit_button.click(
+            fn=ask.run_query_gradio,
+            inputs=[
+                query_input,
+                date_restrict_input,
+                target_site_input,
+                output_language_input,
+                output_length_input,
+                url_list_input,
+                inference_model_name_input,
+                hybrid_search_input,
+                output_mode_input,
+                extract_schema_input,
+            ],
+            outputs=[answer_output, logs_output],
+        )
+
+    demo.queue().launch(share=share_ui)
+
+
+@click.command(help="Search web for the query and summarize the results.")
+@click.option("--query", "-q", required=False, help="Query to search")
+@click.option(
+    "--output-mode",
+    "-o",
+    type=click.Choice(["answer", "extract"], case_sensitive=False),
+    default="answer",
+    required=False,
+    help="Output mode for the answer, default is a simple answer",
+)
+@click.option(
+    "--date-restrict",
+    "-d",
+    type=int,
+    required=False,
+    default=0,
+    help="Restrict search results to a specific date range, default is no restriction",
+)
+@click.option(
+    "--target-site",
+    "-s",
+    required=False,
+    default="",
+    help="Restrict search results to a specific site, default is no restriction",
+)
+@click.option(
+    "--output-language",
+    required=False,
+    default="English",
+    help="Output language for the answer",
+)
+@click.option(
+    "--output-length",
+    type=int,
+    required=False,
+    default=0,
+    help="Output length for the answer",
+)
+@click.option(
+    "--url-list-file",
+    type=str,
+    required=False,
+    default="",
+    show_default=True,
+    help="Instead of doing web search, scrape the target URL list and answer the query based on the content",
+)
+@click.option(
+    "--extract-schema-file",
+    type=str,
+    required=False,
+    default="",
+    show_default=True,
+    help="Pydantic schema for the extract mode",
+)
+@click.option(
+    "--inference-model-name",
+    "-m",
+    required=False,
+    default="gpt-4o-mini",
+    help="Model name to use for inference",
+)
+@click.option(
+    "--hybrid-search",
+    is_flag=True,
+    help="Use hybrid search mode with both vector search and full-text search",
+)
+@click.option(
+    "--web-ui",
+    is_flag=True,
+    help="Launch the web interface",
+)
+@click.option(
+    "-l",
+    "--log-level",
+    "log_level",
+    default="INFO",
+    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR"], case_sensitive=False),
+    help="Set the logging level",
+    show_default=True,
+)
+def search_extract_summarize(
+    query: str,
+    output_mode: str,
+    date_restrict: int,
+    target_site: str,
+    output_language: str,
+    output_length: int,
+    url_list_file: str,
+    extract_schema_file: str,
+    inference_model_name: str,
+    hybrid_search: bool,
+    web_ui: bool,
+    log_level: str,
+):
+    load_dotenv(dotenv_path=default_env_file, override=False)
+    logger = _get_logger(log_level)
+
+    if output_mode == "extract" and not extract_schema_file:
+        raise Exception("Extract mode requires the --extract-schema-file argument.")
+
+    settings = AskSettings(
+        date_restrict=date_restrict,
+        target_site=target_site,
+        output_language=output_language,
+        output_length=output_length,
+        url_list=_read_url_list(url_list_file),
+        inference_model_name=inference_model_name,
+        hybrid_search=hybrid_search,
+        output_mode=OutputMode(output_mode),
+        extract_schema_str=_read_extract_schema_str(extract_schema_file),
+    )
+
+    if web_ui or os.environ.get("RUN_GRADIO_UI", "false").lower() != "false":
+        if os.environ.get("SHARE_GRADIO_UI", "false").lower() == "true":
+            share_ui = True
+        else:
+            share_ui = False
+        launch_gradio(
+            query=query,
+            init_settings=settings,
+            share_ui=share_ui,
+            logger=logger,
+        )
+    else:
+        if query is None:
+            raise Exception("Query is required for the command line mode")
+        ask = Ask(logger=logger)
+
+        final_result = ask.run_query(query=query, settings=settings)
+        click.echo(final_result)
+
+
+if __name__ == "__main__":
+    search_extract_summarize()

demos/search_and_answer.md

@@ -0,0 +1,57 @@
+```
+% python ask.py -q "Why do we need agentic RAG even if we have ChatGPT?"
+
+✅ Found 10 links for query: Why do we need agentic RAG even if we have ChatGPT?
+✅ Scraping the URLs ...
+✅ Scraped 10 URLs ...
+✅ Chunking the text ...
+✅ Saving to vector DB ...
+✅ Querying the vector DB ...
+✅ Running inference with context ...
+
+# Answer
+
+Agentic RAG (Retrieval-Augmented Generation) is needed alongside ChatGPT for several reasons:
+
+1. **Precision and Contextual Relevance**: While ChatGPT offers generative responses, it may not
+reliably provide precise answers, especially when specific, accurate information is critical[5].
+Agentic RAG enhances this by integrating retrieval mechanisms that improve response context and
+accuracy, allowing users to access the most relevant and recent data without the need for costly
+model fine-tuning[2].
+
+2. **Customizability**: RAG allows businesses to create tailored chatbots that can securely
+reference company-specific data[2]. In contrast, ChatGPT’s broader capabilities may not be
+directly suited for specialized, domain-specific questions without comprehensive customization[3].
+
+3. **Complex Query Handling**: RAG can be optimized for complex queries and can be adjusted to
+work better with specific types of inputs, such as comparing and contrasting information, a task
+where ChatGPT may struggle under certain circumstances[9]. This level of customization can lead to
+better performance in niche applications where precise retrieval of information is crucial.
+
+4. **Asynchronous Processing Capabilities**: Future agentic systems aim to integrate asynchronous
+handling of actions, allowing for parallel processing and reducing wait times for retrieval and
+computation, which is a limitation in the current form of ChatGPT[7]. This advancement would enhance
+overall efficiency and responsiveness in conversations.
+
+5. **Incorporating Retrieved Information Effectively**: Using RAG can significantly improve how
+retrieved information is utilized within a conversation. By effectively managing the context and
+relevance of retrieved documents, RAG helps in framing prompts that can guide ChatGPT towards
+delivering more accurate responses[10].
+
+In summary, while ChatGPT excels in generating conversational responses, agentic RAG brings
+precision, customization, and efficiency that can significantly enhance the overall conversational
+AI experience.
+
+# References
+
+[1] https://community.openai.com/t/how-to-use-rag-properly-and-what-types-of-query-it-is-good-at/658204
+[2] https://www.linkedin.com/posts/brianjuliusdc_dax-powerbi-chatgpt-activity-7235953280177041408-wQqq
+[3] https://community.openai.com/t/how-to-use-rag-properly-and-what-types-of-query-it-is-good-at/658204
+[4] https://community.openai.com/t/prompt-engineering-for-rag/621495
+[5] https://www.ben-evans.com/benedictevans/2024/6/8/building-ai-products
+[6] https://community.openai.com/t/prompt-engineering-for-rag/621495
+[7] https://www.linkedin.com/posts/kurtcagle_agentic-rag-personalizing-and-optimizing-activity-7198097129993613312-z7Sm
+[8] https://community.openai.com/t/how-to-use-rag-properly-and-what-types-of-query-it-is-good-at/658204
+[9] https://community.openai.com/t/how-to-use-rag-properly-and-what-types-of-query-it-is-good-at/658204
+[10] https://community.openai.com/t/prompt-engineering-for-rag/621495
+```

demos/search_and_extract.md

@@ -0,0 +1,200 @@
+```
+% python ask.py -q "LLM Gen-AI Startups" -o extract --extract-schema-file instructions/extract_example.txt
+2024-10-29 08:15:24,320 - INFO - Searching the web ...
+2024-10-29 08:15:24,684 - INFO - ✅ Found 10 links for query: LLM Gen-AI Startups
+2024-10-29 08:15:24,684 - INFO - Scraping the URLs ...
+2024-10-29 08:15:24,685 - INFO - Scraping https://www.ycombinator.com/companies/industry/generative-ai ...
+2024-10-29 08:15:24,686 - INFO - Scraping https://app.dealroom.co/lists/33530 ...
+2024-10-29 08:15:24,687 - INFO - Scraping https://explodingtopics.com/blog/generative-ai-startups ...
+2024-10-29 08:15:24,688 - INFO - Scraping https://www.reddit.com/r/learnprogramming/comments/1e0gzbo/are_most_ai_startups_these_days_just_openai/ ...
+2024-10-29 08:15:24,689 - INFO - Scraping https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc ...
+2024-10-29 08:15:24,690 - INFO - Scraping https://www.reddit.com/r/ycombinator/comments/16xhwz7/is_it_really_impossible_for_genai_startups_to/ ...
+2024-10-29 08:15:24,691 - INFO - Scraping https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9 ...
+2024-10-29 08:15:24,692 - INFO - Scraping https://a16z.com/ai/ ...
+2024-10-29 08:15:24,693 - INFO - Scraping https://www.eweek.com/artificial-intelligence/generative-ai-startups/ ...
+2024-10-29 08:15:24,695 - INFO - Scraping https://cohere.com/ ...
+2024-10-29 08:15:24,875 - WARNING - Body text too short for url: https://app.dealroom.co/lists/33530, length: 41
+2024-10-29 08:15:24,975 - INFO - ✅ Successfully scraped https://explodingtopics.com/blog/generative-ai-startups with length: 17631
+2024-10-29 08:15:25,429 - INFO - ✅ Successfully scraped https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9 with length: 3649
+2024-10-29 08:15:26,119 - INFO - ✅ Successfully scraped https://a16z.com/ai/ with length: 14828
+2024-10-29 08:15:26,144 - INFO - ✅ Successfully scraped https://cohere.com/ with length: 2696
+2024-10-29 08:15:26,220 - INFO - ✅ Successfully scraped https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc with length: 13858
+2024-10-29 08:15:26,520 - INFO - ✅ Successfully scraped https://www.reddit.com/r/learnprogramming/comments/1e0gzbo/are_most_ai_startups_these_days_just_openai/ with length: 2029
+2024-10-29 08:15:26,541 - INFO - ✅ Successfully scraped https://www.reddit.com/r/ycombinator/comments/16xhwz7/is_it_really_impossible_for_genai_startups_to/ with length: 3445
+2024-10-29 08:15:26,947 - WARNING - Body text too short for url: https://www.ycombinator.com/companies/industry/generative-ai, length: 0
+2024-10-29 08:15:26,989 - INFO - ✅ Successfully scraped https://www.eweek.com/artificial-intelligence/generative-ai-startups/ with length: 69104
+2024-10-29 08:15:26,990 - INFO - ✅ Scraped 8 URLs.
+2024-10-29 08:15:26,990 - INFO - Extracting structured data ...
+2024-10-29 08:15:34,019 - INFO - ✅ Finished inference API call. Extracted 33 items from https://explodingtopics.com/blog/generative-ai-startups.
+2024-10-29 08:15:34,490 - INFO - ✅ Finished inference API call. Extracted 0 items from https://www.reddit.com/r/learnprogramming/comments/1e0gzbo/are_most_ai_startups_these_days_just_openai/.
+2024-10-29 08:15:38,135 - INFO - ✅ Finished inference API call. Extracted 20 items from https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc.
+2024-10-29 08:15:39,165 - INFO - ✅ Finished inference API call. Extracted 2 items from https://www.reddit.com/r/ycombinator/comments/16xhwz7/is_it_really_impossible_for_genai_startups_to/.
+2024-10-29 08:15:40,463 - INFO - ✅ Finished inference API call. Extracted 7 items from https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9.
+2024-10-29 08:15:44,150 - INFO - ✅ Finished inference API call. Extracted 23 items from https://a16z.com/ai/.
+2024-10-29 08:16:02,785 - INFO - ✅ Finished inference API call. Extracted 73 items from https://www.eweek.com/artificial-intelligence/generative-ai-startups/.
+2024-10-29 08:16:04,423 - INFO - ✅ Finished inference API call. Extracted 3 items from https://cohere.com/.
+2024-10-29 08:16:04,423 - INFO - ✅ Finished extraction from all urls.
+2024-10-29 08:16:04,423 - INFO - Generating output ...
+name,description,SourceURL
+Cohere,Cohere is an AI startup that builds multilingual LLMs for enterprise businesses to streamline tasks.,https://explodingtopics.com/blog/generative-ai-startups
+Hugging Face,"Hugging Face is a collaborative AI community that creates tools for developers, offering over 61,000 pre-trained models and 7,000 datasets.",https://explodingtopics.com/blog/generative-ai-startups
+Tabnine,Tabnine is an AI assistant for software developers that uses generative AI to predict or suggest the next lines of code.,https://explodingtopics.com/blog/generative-ai-startups
+Soundraw,Soundraw is a royalty-free AI music generator allowing creators to make original songs.,https://explodingtopics.com/blog/generative-ai-startups
+Tome.app,Tome is an AI-powered storytelling platform that helps users create presentations using generative AI.,https://explodingtopics.com/blog/generative-ai-startups
+AssemblyAI,AssemblyAI is an AI-as-a-service startup providing APIs in 80 different languages for automated speech transcription.,https://explodingtopics.com/blog/generative-ai-startups
+Promptbase,Promptbase is a marketplace for buying and selling prompts to generate content with AI tools.,https://explodingtopics.com/blog/generative-ai-startups
+Photoroom,PhotoRoom is an AI-powered photo editing tool that combines generative AI with traditional editing tools.,https://explodingtopics.com/blog/generative-ai-startups
+Taskade,Taskade is a generative AI productivity tool for task management and team collaboration.,https://explodingtopics.com/blog/generative-ai-startups
+Synthesia,Synthesia AI is a generative AI video maker that creates videos from text in multiple languages.,https://explodingtopics.com/blog/generative-ai-startups
+Humata AI,Humata AI is a tool integrating with your desktop to answer questions about documents using generative AI.,https://explodingtopics.com/blog/generative-ai-startups
+Chatbase,"Chatbase is a chatbot integrated into websites, providing instant answers to users.",https://explodingtopics.com/blog/generative-ai-startups
+Stability AI,"Stability AI is known for creating Stable Diffusion, a deep learning text-to-image AI model.",https://explodingtopics.com/blog/generative-ai-startups
+Anyword,Anyword is a generative AI content generation platform that uses natural language processing for copywriting.,https://explodingtopics.com/blog/generative-ai-startups
+Rephrase AI,Rephrase AI is a text-to-video generation platform that allows customers to create personalized videos.,https://explodingtopics.com/blog/generative-ai-startups
+Inworld AI,Inworld AI specializes in AI-powered character generation for video games.,https://explodingtopics.com/blog/generative-ai-startups
+Runway,Runway is a generative AI video editing platform that produces videos based on text prompts.,https://explodingtopics.com/blog/generative-ai-startups
+Sudowrite,Sudowrite is a generative AI writing assistant designed for novel writing and storytelling.,https://explodingtopics.com/blog/generative-ai-startups
+Steve.ai,Steve.ai is an online video creation platform that turns text prompts into animated videos.,https://explodingtopics.com/blog/generative-ai-startups
+PlayHT,PlayHT is a text-to-speech software that uses generative AI to create audio from text.,https://explodingtopics.com/blog/generative-ai-startups
+Elicit,Elicit is a generative AI research tool for finding and analyzing academic papers.,https://explodingtopics.com/blog/generative-ai-startups
+TalkPal,TalkPal is an AI-powered language learning platform that personalizes sessions based on the user's level.,https://explodingtopics.com/blog/generative-ai-startups
+Dubverse,Dubverse is an AI video dubbing platform capable of translating videos into multiple languages.,https://explodingtopics.com/blog/generative-ai-startups
+Codeium,Codeium is an AI-powered toolkit for developers that auto-generates and explains code.,https://explodingtopics.com/blog/generative-ai-startups
+Fliki,Fliki is an AI video and audio generation platform that incorporates text to speech capabilities.,https://explodingtopics.com/blog/generative-ai-startups
+LOVO AI,LOVO is an AI voice generator startup focused on text-to-speech and voice cloning.,https://explodingtopics.com/blog/generative-ai-startups
+Decktopus,"Decktopus creates presentations from prompts, streamlining slide generation.",https://explodingtopics.com/blog/generative-ai-startups
+Character.ai,Character AI is a generative AI platform that generates customizable animated chatbots.,https://explodingtopics.com/blog/generative-ai-startups
+Descript,Descript is a generative AI video and audio editing application catering to podcasters and videographers.,https://explodingtopics.com/blog/generative-ai-startups
+Papercup,"Papercup uses AI to translate speech and dubbing, creating realistic voiceovers.",https://explodingtopics.com/blog/generative-ai-startups
+Vizcom,Vizcom is a generative AI tool that aids designers in creating 3D concept drawings.,https://explodingtopics.com/blog/generative-ai-startups
+Vidnoz,Vidnoz is a free AI video platform aimed at reducing costs and increasing productivity.,https://explodingtopics.com/blog/generative-ai-startups
+Scalenut,Scalenut is an AI-powered SEO and content marketing platform that automates content creation.,https://explodingtopics.com/blog/generative-ai-startups
+Huma.AI,"A generative AI for life sciences SaaS platform, recognized by Gartner in multiple reports and collaborating with OpenAI for a validated GenAI solution for medical affairs.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Viz.ai,"A medical imaging startup specializing in stroke care and expanded into cardiology and oncology, using LLMs for early disease detection.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Arionkoder,"A product development studio and AI lab specializing in AI, computer vision, and ML solutions for healthcare.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+HeHealth,Delivers AI and LLM technologies for efficient recommendations for male healthcare.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+HOPPR,A multimodal imaging platform improving communication and medical processes through deep image analysis.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Medical IP,A medical metaverse solution utilizing generative AI for streamlined medical imaging segmentation.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+NexusMD,An LLM-powered medical imaging platform automating medical imaging data capture across service sites.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Abridge,"A leading generative AI for clinical documentation, converting patient-clinician conversations into structured notes.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Autonomize AI,A healthcare-optimized AI platform that cuts clinical administrative time and accelerates care gap closures.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+DeepScribe,"A med-tech firm leveraging LLMs to automate clinical documentation, reducing clinician burnout.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+HiLabs,Utilizes AI and LLMs to refine data and identify care gaps for large health plans.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Nabla,"Offers Copilot, an ambient AI for physicians that streamlines clinical note generation.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+AgentifAI,A voice-first AI assistant for healthcare enhancing patient experience.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Artisight,An end-to-end sensor fusion platform deployed in hospitals to enhance operational efficiency.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+dacadoo,"A digital health platform connecting to various devices, with plans to incorporate an LLM-based streaming model.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Hippocratic AI,Developing a safety-focused LLM for patient-facing applications.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Idoven,An AI-powered cardiology platform with deep-learning models for patient diagnosis.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Inference Analytics,A generative AI healthcare platform trained on a vast dataset for various impactful healthcare use cases.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Pingoo,"An AI health chatbot providing personalized health education, serving various health systems.",https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Talkie.ai,Automates patient phone interactions using AI voice and LLM technology for healthcare organizations.,https://www.linkedin.com/pulse/20-gen-ai-healthcare-startups-shaping-future-recap-from-renee-yao-q7lkc
+Jasper,Jasper (YC GenAI company) who became one of the fastest growing startups of all time is losing customers fast. It is often cited as an example of how GenAI companies struggle to develop a moat.,https://www.reddit.com/r/ycombinator/comments/16xhwz7/is_it_really_impossible_for_genai_startups_to/
+Unnamed GenAI Startup,"We are a GenAI startup that automates tasks in a specific niche area and utilizes a network of LLMs. Our MVP is looking great, and we have a substantial interest from investors.",https://www.reddit.com/r/ycombinator/comments/16xhwz7/is_it_really_impossible_for_genai_startups_to/
+beautiful.ai,A startup providing tools for creating presentations with an innovative approach.,https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9
+Tome,A startup focused on revolutionizing presentation tools.,https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9
+Rows,A startup rethinking spreadsheets with an LLM-first perspective.,https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9
+mem,A note-taking startup utilizing LLM technology.,https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9
+Clio,"A practice management solution for law firms, sitting on a wealth of data to build AI solutions.",https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9
+Bench,An accounting startup that has implemented auto-pilot strategies.,https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9
+Pilot,A recent entrant in the accounting space following a similar auto-pilot approach.,https://medium.com/point-nine-news/where-are-the-opportunities-for-new-startups-in-generative-ai-f48068b5f8f9
+a16z,"A venture capital firm that invests in technology companies, with a focus on artificial intelligence and related sectors.",https://a16z.com/ai/
+AI Stack Products,"A collection of open-source AI stacks and tools for developers, including projects for building AI companions and chatbots.",https://a16z.com/ai/
+Llama2 Chatbot,A 13 billion parameter language model fine-tuned for chat completions systems.,https://a16z.com/ai/
+AI Grants,"Grant funding for AI developers focused on LLM training, hosting, and evaluation.",https://a16z.com/ai/
+AI Canon,"A curated collection of impactful papers, posts, courses, and guides on modern artificial intelligence.",https://a16z.com/ai/
+Brain Trust,A community-driven platform aimed at training AI models with human data.,https://a16z.com/ai/
+Character.AI,A platform for creating and interacting with AI characters.,https://a16z.com/ai/
+Civiti,A startup focused on deploying community-driven AI models.,https://a16z.com/ai/
+Creta,A developer's assistant using AI for coding support.,https://a16z.com/ai/
+Databricks,A company that provides a Unified Analytics Platform powered by Apache Spark.,https://a16z.com/ai/
+ElevenLabs,An AI company that specializes in voice generation and text-to-speech technologies.,https://a16z.com/ai/
+Freeno,A healthcare-focused AI startup working on early detection systems.,https://a16z.com/ai/
+OpenAI,An AI research lab dedicated to ensuring that artificial general intelligence benefits all of humanity.,https://a16z.com/ai/
+Zuma,An AI startup aimed at enhancing user experience through intelligent design.,https://a16z.com/ai/
+Nautilus Biotechnology,A company transforming the experience and outcome of biotech with AI applications.,https://a16z.com/ai/
+Saronic,An AI model focused on enhancing predictive analytics in business settings.,https://a16z.com/ai/
+Mistral AI,A company developing scaled AI technologies for multiple applications.,https://a16z.com/ai/
+Turquoise Health,An AI-driven health technology startup offering transparent healthcare pricing.,https://a16z.com/ai/
+Rasa,An open-source framework for building AI assistants.,https://a16z.com/ai/
+Viggle,A startup revolutionizing how audiences engage with multimedia through AI.,https://a16z.com/ai/
+Waymark,A company dedicated to automating video production through generative AI techniques.,https://a16z.com/ai/
+Yolo AI,An emerging company specializing in real-time object detection technology.,https://a16z.com/ai/
+Luma AI,An innovative AI platform designed to enhance the visual experience in various sectors.,https://a16z.com/ai/
+OpenAI,"OpenAI is the highest profile company in the generative AI space. Along with its prebuilt AI solutions, OpenAI also offers API and application development support for developers who want to use its models as baselines. Its close partnership with Microsoft and growing commitment to ethical AI continue to boost its reputation and reach.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Anthropic,"Anthropic’s Claude platform is similar to OpenAI’s ChatGPT, with its large language model and content generation focus. Claude has evolved into an enterprise-level AI assistant with high-level conversational capabilities.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Cohere,Cohere offers natural language processing (NLP) solutions that are specifically designed to support business operations. Its conversational AI agent allows enterprise users to quickly search for and retrieve company information.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Glean,"Glean is a generative AI enterprise search company that connects to a variety of enterprise apps and platforms, enabling easy access to business information sources with a focus on AI privacy and governance.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Jasper,"Jasper’s core product is designed for marketing content generation, effective for establishing a consistent brand voice and managing digital marketing campaigns. Jasper also acquired the AI image platform Clickdrop.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Hugging Face,"Hugging Face is a community forum focused on AI and ML model development, offering access to BLOOM, an open-source LLM that can generate content in multiple languages.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Inflection AI,"Inflection AI, founded by former leaders from LinkedIn and DeepMind, focuses on creating conversational AI tools, recently releasing Pi, a personal AI tool.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Stability AI,"Stability AI specializes in generative AI for image and video content generation, with its app Stable Diffusion being a popular solution in the industry.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+MOSTLY AI,"MOSTLY AI specializes in synthetic data generation, balancing data democratization with anonymity and security requirements particularly useful in banking and telecommunications.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Lightricks,"Lightricks is known for its social media-friendly image editing app, Facetune, and uses AI for content generation and avatar creation.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+AI21 Labs,"AI21 Labs creates enterprise tools focusing on contextual natural language processing, allowing third-party developers to build on their language models.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Tabnine,"Tabnine offers generative AI code assistance for software development, helping with code completion and other programming tasks.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Mistral AI,"Mistral AI provides developer-facing open AI models and deployment resources, focusing on scalable AI solutions.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Codeium,"Codeium is a generative AI company that provides resources for generating logical code, with features for autocomplete and contextual knowledge.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Clarifai,"Clarifai's multipurpose platform allows users to build, deploy, and manage AI data projects across various sectors.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Gong,"Gong provides revenue intelligence solutions that use generative AI to enhance sales coaching, customer service engagement, and revenue forecasting.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Twain,"Twain is an AI writing assistant that helps sales professionals generate captivating content, particularly for outreach emails.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Bertha.ai,"Bertha.ai specializes in content generation solutions for WordPress and similar platforms, assisting with written content and imagery.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Tome,Tome is a creative generative AI platform known for its versatile interface to create presentations and reports.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+CopyAI,CopyAI's platform supports marketing and sales professionals in generating effective go-to-market strategies.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Synthesia,"Synthesia focuses on AI-driven video creation, allowing users to generate professional-quality videos based on simple text inputs.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Midjourney,"Midjourney offers a generative AI solution for image and artwork creation, notable for its advanced editing features.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+MURF.AI,"MURF.AI provides text-to-speech solutions with bidirectional voice capabilities, designed for creative content production.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+PlayHT,PlayHT specializes in AI voice generation and personalized podcast content creation.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+ElevenLabs,ElevenLabs is renowned for its high-quality voice generation technology and enterprise scalability.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Colossyan,Colossyan offers tools for creating corporate training videos without the need for actors or original scripting.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+AssemblyAI,AssemblyAI provides speech-to-text modeling and transcription solutions with strong analysis capacities.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Plask,Plask automates animation processes and simplifies creation of hyper-realistic 3D motion videos.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+LOVO,LOVO delivers video and voice AI generation solutions through its comprehensive platform called Genny.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+DeepBrain AI,"DeepBrain AI produces AI-generated videos including interactive virtual assistants, enhancing accessibility in public service.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Elai.io,"Elai.io provides collaborative tools for AI video generation, tailored for business audiences.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Sudowrite,"Sudowrite supports writers by expanding on story outlines, generating ideas, and creating AI art.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Tavus,Tavus enables automated video generation personalized for each viewer's characteristics.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Hippocratic AI,Hippocratic AI offers a generative AI platform for healthcare focused on patient care and HIPAA compliance.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Paige AI,Paige AI integrates generative AI for optimizing cancer diagnostics and pathology.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Iambic Therapeutics,Iambic Therapeutics optimizes drug discovery using machine learning in the oncology sector.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Insilico Medicine,Insilico Medicine uses AI for efficient drug development across various medical fields.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Etcembly,Etcembly enhances T-cell receptor immunotherapies through machine learning advancements.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Biomatter,Biomatter employs AI for intelligent architecture in protein design across multiple sectors.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Activ Surgical,Activ Surgical utilizes AI for enhanced surgical guidance and visualization.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Kaliber Labs,Kaliber Labs designs AI-powered surgical software for improved communication and patient experiences.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Osmo,Osmo utilizes machine learning in olfactory science to predict smells based on molecular structure.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Aqemia,Aqemia focuses on AI-assisted drug discovery incorporating both quantum and statistical mechanics.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Synthetaic,Synthetaic's platform generates AI models for analyzing unstructured and unlabeled datasets.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Synthesis AI,Synthesis AI develops synthetic data-driven imagery and human simulations for ethical AI applications.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Syntho,Syntho generates synthetic data twins for analytics and product demos while ensuring ease of use.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+GenRocket,GenRocket emphasizes automation in synthetic data generation and management for various industries.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Gridspace,Gridspace creates hybrid voice AI and human agent solutions for improved contact center management.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Revery AI,Revery AI utilizes generative AI to create virtual dressing rooms and smart shopping assistants.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Veesual,Veesual offers deep learning-based virtual try-on solutions for e-commerce.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Frame AI,Frame AI analyzes customer interactions to provide insights for improving customer service.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Zowie,Zowie specializes in AI customer service technology tailored for e-commerce environments.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Forethought,Forethought provides generative AI solutions for optimizing customer service workflows.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Lily AI,Lily AI employs AI to enhance product management and customer service experiences for retailers.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Runway,Runway enables filmmakers to use AI for cinema-quality video production.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Latitude.io,"Latitude.io offers AI-driven gaming experiences, allowing users to create dynamic narratives.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Character.AI,Character.AI allows users to develop and interact with user-created virtual characters.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Charisma Entertainment,Charisma Entertainment creates engaging narratives and character-driven storylines for various media.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Replika,Replika generates AI companions for personalized conversations and social interactions.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Aimi.fm,Aimi.fm provides users with a generative AI music player for composing customized music loops.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Inworld AI,Inworld AI utilizes generative AI to enhance the realism of non-player characters in gaming and media.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+SOUNDRAW,SOUNDRAW enables tailored music composition for various media including videos and games.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Notion,Notion offers AI-assisted task management tools for improved workflow efficiency.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Harvey,Harvey targets the legal sector with generative AI-driven professional services support.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Ironclad,Ironclad provides AI contract management tools for simplifying contract workflows across industries.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Taskade,Taskade focuses on AI-powered task management and collaborative tools for creative projects.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Humata,"Humata helps users extract useful insights from documents and files, enhancing knowledge management.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Simplifai,"Simplifai automates banking and finance processes, offering solutions tailored to regulatory requirements.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+PatentPal,"PatentPal generates drafts for patent specifications, optimizing the intellectual property protection process.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Adept AI,Adept AI utilizes natural language processing to enhance workplace interactions and automate workflows.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Perplexity AI,"Perplexity AI offers a personalized AI search engine, resembling chatbots with more detailed outputs.",https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Andi,Andi is a friendly generative AI search bot that summarizes web information efficiently.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+You.com,You.com is a private search engine that uses AI to summarize and personalize search results.,https://www.eweek.com/artificial-intelligence/generative-ai-startups/
+Cohere Command,"Command models are used by companies to build production-ready, scalable and efficient AI-powered applications.",https://cohere.com/
+Cohere Embed,"Unlocking the full potential of your enterprise data with the highest performing embedding model, supporting over 100 languages.",https://cohere.com/
+Cohere Rerank,"Surfaces the industry’s most accurate responses, combining Rerank and Embed for reliable and up-to-date responses.",https://cohere.com/
+```

demos/search_on_site_and_date.md

@@ -0,0 +1,44 @@
+This following query will only use the information from openai.com that are updated in the previous
+day. The behavior is similar to the "site:openai.com" and "date-restrict" search parameters in Google
+search.
+
+```
+% python ask.py -q "OpenAI Swarm Framework" -d 1 -s openai.com
+✅ Found 10 links for query: OpenAI Swarm Framework
+✅ Scraping the URLs ...
+✅ Scraped 10 URLs ...
+✅ Chunking the text ...
+✅ Saving to vector DB ...
+✅ Querying the vector DB to get context ...
+✅ Running inference with context ...
+
+# Answer
+
+OpenAI Swarm Framework is an experimental platform designed for building, orchestrating, and
+deploying multi-agent systems, enabling multiple AI agents to collaborate on complex tasks. It contrasts
+with traditional single-agent models by facilitating agent interaction and coordination, thus enhancing
+efficiency[5][9]. The framework provides developers with a way to orchestrate these agent systems in
+a lightweight manner, leveraging Node.js for scalable applications[1][4].
+
+One implementation of this framework is Swarm.js, which serves as a Node.js SDK, allowing users to
+create and manage agents that perform tasks and hand off conversations. Swarm.js is positioned as
+an educational tool, making it accessible for both beginners and experts, although it may still contain
+bugs and is currently lightweight[1][3][7]. This new approach emphasizes multi-agent collaboration and is
+well-suited for back-end development, requiring some programming expertise for effective implementation[9].
+
+Overall, OpenAI Swarm facilitates a shift in how AI systems can collaborate, differing from existing
+OpenAI tools by focusing on backend orchestration rather than user-interactive front-end applications[9].
+
+# References
+
+[1] https://community.openai.com/t/introducing-swarm-js-node-js-implementation-of-openai-swarm/977510
+[2] https://community.openai.com/t/introducing-swarm-js-a-node-js-implementation-of-openai-swarm/977510
+[3] https://community.openai.com/t/introducing-swarm-js-node-js-implementation-of-openai-swarm/977510
+[4] https://community.openai.com/t/introducing-swarm-js-a-node-js-implementation-of-openai-swarm/977510
+[5] https://community.openai.com/t/swarm-some-initial-insights/976602
+[6] https://community.openai.com/t/swarm-some-initial-insights/976602
+[7] https://community.openai.com/t/introducing-swarm-js-node-js-implementation-of-openai-swarm/977510
+[8] https://community.openai.com/t/introducing-swarm-js-a-node-js-implementation-of-openai-swarm/977510
+[9] https://community.openai.com/t/swarm-some-initial-insights/976602
+[10] https://community.openai.com/t/swarm-some-initial-insights/976602
+```

instructions/extract_example.txt

@@ -0,0 +1,3 @@
+class CompanyInfo(BaseModel):
+    name: str
+    description: str

instructions/links.txt

@@ -0,0 +1,4 @@
+# you can specify a --url-list-file argument with links similar to the ones below
+# ask.py will crawl these pages and answer the question based on their contents
+https://en.wikipedia.org/wiki/Large_language_model
+https://en.wikipedia.org/wiki/Retrieval-augmented_generation

requirements.txt

@@ -0,0 +1,9 @@
+click==8.1.7
+requests==2.31.0
+openai==1.40.2
+jinja2==3.1.3
+bs4==0.0.2
+lxml==4.8.0
+python-dotenv==1.0.1
+duckdb==1.1.2
+gradio==5.3.0