Merge pull request #18 from gperdrizet/dev

assets/html.py

@@ -1,33 +0,0 @@
-'''HTML elements for Gradio interface.'''
-
-TITLE = (
-    '''
-        <center> 
-            <h1>RSS feed reader</h1>
-        </center>
-    '''
-)
-
-DESCRIPTION = (
-    '''
-        <p>RSS feed reader MCP server. See 
-        <a href="https://huggingface.co/spaces/Agents-MCP-Hackathon/rss-mcp-client">
-        Agentic RSS reader</a>for a demonstration. Check out the 
-        <a href="https://github.com/gperdrizet/MCP-hackathon/tree/main">
-        main project repo on GitHub</a>. Both Spaces by 
-        <a href="https://www.linkedin.com/in/gperdrizet">George Perdrizet</a>.</p>
-
-        <p>This Space is not meant to be used directly, but you can try out the bare tool below.
-        Enter a website name, website URL, or feed URI. The tool will do it's best
-        to find the feed and return titles, links and summaries for the three most recent posts.
-        Suggestions: http://openai.com/news/rss.xml, hackernews.com, slashdot, etc.</p>
-
-        <h2>Tools</h2>
-
-        <ol>
-            <li><b>DONE</b> Given a website name or URL, find its RSS feed and return recent
-                article titles, links and a generated summary of content if avalible</li>
-            <li><b>TODO</b> Simple RAG on requested RSS feed content</li>
-        </ol>
-    '''
-)

assets/text.py

@@ -0,0 +1,32 @@
+'''HTML elements for Gradio interface.'''
+
+TITLE = ('''
+    <center> 
+        <h1>RSS feed reader</h1>
+    </center>
+''')
+
+DESCRIPTION = ('''
+    RSS feed reader MCP server. See 
+    [Agentic RSS reader](https://huggingface.co/spaces/Agents-MCP-Hackathon/rss-mcp-client) 
+    for a demonstration. Check out the 
+    [main project repo on GitHub](https://github.com/gperdrizet/MCP-hackathon/tree/main)
+    . Both Spaces by 
+    [George Perdrizet](https://www.linkedin.com/in/gperdrizet)
+
+    This space is not meant to be used directly. It exposes a set of tools to
+    interact with RSS feeds for use by agents. For testing and demonstration,
+    you can try the tools directly below.
+
+    ## Tools
+
+    1. `get_feed()`: Given a website name or URL, find its RSS feed and
+        return recent article titles, links and a generated summary of content if
+        avalible. Caches results for fast retrieval by other tools. Embeds content
+        to vector database for subsequent RAG.
+    2. `context_search()`: Vector search on article content for RAG context.
+    3. `find_article()`: Uses vector search on article content to find title of article
+        that user is referring to.
+    4. `get_summary()`: Gets article summary from Redis cache using article title.
+    5. `get_link()`: Gets article link from Redis cache using article title.
+''')

functions/feed_extraction.py

@@ -2,7 +2,6 @@
 
 import os
 import re
-import json
 import logging
 import urllib.request
 from urllib.error import HTTPError, URLError
@@ -53,8 +52,8 @@ def find_feed_uri(website: str) -> str:
         feed_uri = FEED_URIS[website]
         logger.info('%s feed URI in local cache: %s', website, feed_uri)
 
-    # Then, check to see if the URI is in the Redis cache
-    cache_key = f"{website.lower().replace(' ', '_')}-feed-uri"
+    # If we still haven't found it, check to see if the URI is in the Redis cache
+    cache_key = f'{website} feed uri'
     cache_hit = False
 
     if feed_uri is None:
@@ -65,7 +64,7 @@ def find_feed_uri(website: str) -> str:
             feed_uri = cached_uri
             logger.info('%s feed URI in Redis cache: %s', website, feed_uri)
 
-    # If none of those get it - try feedparse if it looks like a url
+    # If still none of those methods get it - try feedparse if it looks like a url
     # or else just google it
     if feed_uri is None:
         if website.split('.')[-1] in COMMON_EXTENSIONS:
@@ -79,6 +78,7 @@ def find_feed_uri(website: str) -> str:
         feed_uri = _get_feed(website_url)
         logger.info('get_feed() returned %s', feed_uri)
 
+        # Add to local cache
         FEED_URIS[website] = feed_uri
 
     # Add the feed URI to the redis cache if it wasn't already there
@@ -88,14 +88,16 @@ def find_feed_uri(website: str) -> str:
     return feed_uri
 
 
-def parse_feed(feed_uri: str) -> list:
+def parse_feed(feed_uri: str, n: int) -> list:
     '''Gets content from a remote RSS feed URI.
     
     Args:
         feed_uri: The RSS feed to get content from
+        n: the number of feed entries to parse
 
     Returns:
-        List of titles for the 10 most recent entries in the RSS feed.
+        List of dictionaries for the n most recent entries in the RSS feed.
+        Each dictionary contains 'title', 'link' and 'content' keys.
     '''
 
     logger = logging.getLogger(__name__ + '.parse_feed')
@@ -112,16 +114,15 @@ def parse_feed(feed_uri: str) -> list:
         if 'title' in entry and 'link' in entry:
 
             title = entry.title
+            entry_content['title'] = title
 
-            # Check the Redis cache for this entry
-            cache_key = title.lower().replace(' ', '_')
-            cache_hit = False
-            cached_entry = REDIS.get(cache_key)
+            # Check the Redis cache
+            cached_link = REDIS.get(f'{title} link')
 
-            if cached_entry:
-                cache_hit = True
-                entry_content = json.loads(cached_entry)
+            if cached_link:
                 logger.info('Entry in Redis cache: "%s"', title)
+                entry_content['link'] = cached_link
+                entry_content['content'] = REDIS.get(f'{title} content')
 
             # If its not in the Redis cache, parse it from the feed data
             else:
@@ -129,24 +130,26 @@ def parse_feed(feed_uri: str) -> list:
                 entry_content['link'] = entry.link
                 entry_content['content'] = None
 
+                # Grab the article content from the feed, if provided
                 if 'content' in entry:
                     entry_content['content'] = entry.content
 
-                if entry_content['content'] is None:
+                # If not, try to get the article content from the link
+                elif entry_content['content'] is None:
 
                     html = _get_html(entry_content['link'])
                     content = _get_text(html)
                     entry_content['content'] = content
 
-                logger.info('Parsed entry: "%s"', title)
+                # Add everything to the cache
+                REDIS.set(f'{title} link', entry_content['link'])
+                REDIS.set(f'{title} content', entry_content['content'])
 
-            # Add it to the Redis cache if it wasn't there
-            if cache_hit is False:
-                REDIS.set(cache_key, entry_content)
+                logger.info('Parsed entry: "%s"', title)
 
         entries[i] = entry_content
 
-        if i == 2:
+        if i == n-1:
             break
 
     logger.info('Entries contains %s elements', len(list(entries.keys())))

functions/gradio_functions.py

@@ -2,6 +2,55 @@
 
 import os
 import re
+import logging
+
+from openai import OpenAI
+
+def call_modal() -> None:
+    '''Sends request to Modal to spin up container'''
+
+    logger = logging.getLogger(__name__ + '.call_modal()')
+
+    # Call the modal container so it spins up
+    client = OpenAI(api_key=os.environ['MODAL_API_KEY'])
+
+    client.base_url = (
+        'https://gperdrizet--vllm-openai-compatible-summarization-serve.modal.run/v1'
+    )
+
+    # Default to first avalible model
+    model = client.models.list().data[0]
+    model_id = model.id
+
+    messages = [
+        {
+            'role': 'system',
+            'content': ('Interpret the following proverb in 50 words or less: ' +
+                'A poor craftsman blames the eye of the beholder')
+        }
+    ]
+
+    logger.info('Prompt: %s', messages[0]['content'])
+
+    completion_args = {
+        'model': model_id,
+        'messages': messages,
+    }
+
+    try:
+        response = client.chat.completions.create(**completion_args)
+
+    except Exception as e: # pylint: disable=broad-exception-caught
+        response = None
+        logger.error('Error during Modal API call: %s', e)
+
+    if response is not None:
+        reply = response.choices[0].message.content
+
+    else:
+        reply = None
+
+    logger.info('Reply: %s', reply)
 
 
 def update_log(n: int = 10):

functions/rag.py

@@ -0,0 +1,52 @@
+'''Collection of function for RAG on article texts.'''
+
+import os
+import logging
+import queue
+from semantic_text_splitter import TextSplitter
+from tokenizers import Tokenizer
+from upstash_vector import Index
+
+
+def ingest(rag_ingest_queue: queue.Queue) -> None:
+    '''Semantically chunks article and upsert to Upstash vector db
+    using article title as namespace.'''
+
+    logger = logging.getLogger(__name__ + '.ingest()')
+
+    index = Index(
+        url='https://living-whale-89944-us1-vector.upstash.io',
+        token=os.environ['UPSTASH_VECTOR_KEY']
+    )
+
+    while True:
+
+        namespaces = index.list_namespaces()
+
+        item = rag_ingest_queue.get()
+        logger.info('Upserting "%s": %s', item['title'], item)
+        title = item['title']
+
+        if title not in namespaces:
+            text = item['content']
+            logger.info('Got "%s" from RAG ingest queue', title)
+
+            tokenizer=Tokenizer.from_pretrained('bert-base-uncased')
+            splitter=TextSplitter.from_huggingface_tokenizer(tokenizer, 256)
+            chunks=splitter.chunks(text)
+
+            for i, chunk in enumerate(chunks):
+
+                index.upsert(
+                    [
+                        (
+                            hash(f'{title}-{i}'),
+                            chunk,
+                            {'namespace': title}
+                        )
+                    ],
+                )
+            logger.info('Ingested %s chunks into vector DB', i + 1)
+
+        else:
+            logger.info('%s already in RAG namespace', title)

functions/summarization.py

@@ -25,7 +25,7 @@ def summarize_content(title: str, content: str) -> str:
     logger.info('Summarizing extracted content')
 
     # Check Redis cache for summary
-    cache_key = f"{title.lower().replace(' ', '_')}-summary"
+    cache_key = f'{title} summary'
     cached_summary = REDIS.get(cache_key)
 
     if cached_summary:
@@ -77,6 +77,8 @@ def summarize_content(title: str, content: str) -> str:
     else:
         summary = None
 
+    # Add the new summary to the cache
     REDIS.set(cache_key, summary)
     logger.info('Summarized: "%s"', title)
+
     return summary

functions/tools.py

@@ -1,20 +1,40 @@
 '''Tool functions for MCP server'''
 
+import os
+import threading
 import time
 import json
 import logging
+import queue
+from typing import Tuple
+from upstash_vector import Index
+from upstash_redis import Redis
+
 import functions.feed_extraction as extraction_funcs
 import functions.summarization as summarization_funcs
+import functions.rag as rag_funcs
+
+RAG_INGEST_QUEUE = queue.Queue()
+
+rag_ingest_thread = threading.Thread(
+    target=rag_funcs.ingest,
+    args=(RAG_INGEST_QUEUE,)
+)
+
+rag_ingest_thread.start()
 
 
-def get_feed(website: str) -> list:
+def get_feed(website: str, n: int = 3) -> list:
     '''Gets RSS feed content from a given website. Can take a website or RSS
     feed URL directly, or the name of a website. Will attempt to find RSS
     feed and return title, summary and link to full article for most recent
-    items in feed.
+    n items in feed. This function is slow and resource heavy, only call it when
+    the user wants to check a feed for new content, or asks for content from a
+    feed that you have not retrieved yet.
     
     Args:
         website: URL or name of website to extract RSS feed content from
+        n: (optional) number of articles to parse from feed, defaults to 3
 
     Returns:
         JSON string containing the feed content or 'No feed found' if a RSS
@@ -35,21 +55,161 @@ def get_feed(website: str) -> list:
         return 'No feed found'
 
     # Parse and extract content from the feed
-    content = extraction_funcs.parse_feed(feed_uri)
-    logger.info('parse_feed() returned %s entries', len(list(content.keys())))
+    articles = extraction_funcs.parse_feed(feed_uri, n)
+    logger.info('parse_feed() returned %s entries', len(list(articles.keys())))
 
-    # Summarize each post in the feed
-    for i, item in content.items():
+    # Loop on the posts, sending them to RAG (nonblocking) and summarization (blocking)
+    for i, item in articles.items():
 
+        # Check if content is present
         if item['content'] is not None:
+            logger.info('Summarizing/RAG ingesting: %s', item)
+
+            # Send to RAG ingest
+            RAG_INGEST_QUEUE.put(item.copy())
+            logger.info('"%s" sent to RAG ingest', item['title'])
+
+            # Generate summary and add to content
             summary = summarization_funcs.summarize_content(
                 item['title'],
                 item['content']
             )
-            content[i]['summary'] = summary
 
-        content[i].pop('content', None)
+            articles[i]['summary'] = summary
+            logger.info('Summary of "%s" generated', item['title'])
+
+        # Remove full-text content before returning
+        articles[i].pop('content', None)
 
     logger.info('Completed in %s seconds', round(time.time()-start_time, 2))
 
-    return json.dumps(content)
+    # Return content dictionary as string
+    return json.dumps(articles)
+
+
+def context_search(query: str, article_title: str = None) -> list[Tuple[float, str]]:
+    '''Searches for context relevant to query. Use this Function to search 
+    for additional general information if needed before answering the user's question 
+    about an article. If article_title is provided the search will only return 
+    results from that article. If article_title is omitted, the search will 
+    include all articles currently in the cache. 
+    
+    Ags:
+        query: user query to find context for
+        article_title: optional, use this argument to search only for 
+        context from a specific article, defaults to None
+            
+    Returns:
+        Text relevant to the query
+    '''
+
+    logger = logging.getLogger(__name__ + 'context_search')
+
+    index = Index(
+        url='https://living-whale-89944-us1-vector.upstash.io',
+        token=os.environ['UPSTASH_VECTOR_KEY']
+    )
+
+    results = None
+
+    results = index.query(
+        data=query,
+        top_k=3,
+        include_data=True,
+        namespace=article_title
+    )
+
+    logger.info('Retrieved %s chunks for "%s"', len(results), query)
+
+    return results[0].data
+
+
+def find_article(query: str) -> list[Tuple[float, str]]:
+    '''Uses vector search to find the most likely title of the article 
+    referred to by query. Use this function if the user is asking about
+    an article, but it is not clear what the exact title of the article is.
+    
+    Args:
+        query: query to to find source article tile for
+        
+    Returns:
+        Article title
+    '''
+
+    logger = logging.getLogger(__name__ + 'context_search')
+
+    index = Index(
+        url='https://living-whale-89944-us1-vector.upstash.io',
+        token=os.environ['UPSTASH_VECTOR_KEY']
+    )
+
+    results = None
+
+    results = index.query(
+        data=query,
+        top_k=3,
+        include_metadata=True,
+        include_data=True
+    )
+
+    logger.info('Retrieved %s chunks for "%s"', len(results), query)
+
+    return results[0].metadata['namespace']
+
+
+def get_summary(title: str) -> str:
+    '''Uses article title to retrieve summary of article content.
+    
+    Args:
+        title: exact title of article
+
+    Returns:
+        Short summary of article content.
+    '''
+
+    logger = logging.getLogger(__name__ + '.get_summary()')
+
+    redis = Redis(
+        url='https://sensible-midge-19304.upstash.io',
+        token=os.environ['UPSTASH_REDIS_KEY']
+    )
+
+    cache_key = f'{title} summary'
+    summary = redis.get(cache_key)
+
+    if summary:
+
+        logger.info('Got summary for "%s": %s', title, summary[:100])
+        return summary
+
+    logger.info('Could not find summary for: "%s"', title)
+    return f'No article called "{title}". Make sure you have the correct title.'
+
+
+def get_link(title: str) -> str:
+    '''Uses article title to look up direct link to article content webpage.
+    
+    Args:
+        title: exact title of article
+
+    Returns:
+        Article webpage URL.
+    '''
+
+    logger = logging.getLogger(__name__ + '.get_link()')
+
+    redis = Redis(
+        url='https://sensible-midge-19304.upstash.io',
+        token=os.environ['UPSTASH_REDIS_KEY']
+    )
+
+    cache_key = f'{title} link'
+    link = redis.get(cache_key)
+
+    if link:
+
+        logger.info('Got link for "%s": %s', title, link)
+        return link
+
+    logger.info('Could not find link for: "%s"', title)
+    return f'No article called "{title}". Make sure you have the correct title.'

requirements.txt

@@ -5,4 +5,7 @@ googlesearch-python
 gradio
 mcp
 openai
-upstash-redis
+semantic-text-splitter
+tokenizers
+upstash-redis
+upstash-vector

rss_server.py

@@ -1,18 +1,19 @@
 '''Main script to run gradio interface and MCP server.'''
 
 import logging
-from functools import partial
 from pathlib import Path
 from logging.handlers import RotatingFileHandler
 
 import gradio as gr
-import assets.html as html
+import assets.text as text
 import functions.tools as tool_funcs
 import functions.gradio_functions as gradio_funcs
 
+# Call the modal container so it spins up before the rest of
+# the app starts
+gradio_funcs.call_modal()
 
-# Set-up logging
-# Make sure log directory exists
+# Set-up logging - make sure log directory exists
 Path('logs').mkdir(parents=True, exist_ok=True)
 
 # Clear old logs if present
@@ -36,11 +37,14 @@ logger = logging.getLogger(__name__)
 with gr.Blocks() as demo:
 
     # Page text
-    gr.HTML(html.TITLE)
-    gr.HTML(html.DESCRIPTION)
+    gr.HTML(text.TITLE)
+    gr.Markdown(text.DESCRIPTION)
+
 
     # Log output
-    dialog_output = gr.Textbox(label='Server logs', lines=10, max_lines=100)
+    with gr.Row():
+        dialog_output = gr.Textbox(label='Server logs', lines=7, max_lines=5)
+
     timer = gr.Timer(0.5, active=True)
 
     timer.tick( # pylint: disable=no-member
@@ -49,19 +53,132 @@ with gr.Blocks() as demo:
         show_api=False
     )
 
+
     # Get feed tool
-    website_url = gr.Textbox('hackernews.com', label='Website')
-    output = gr.Textbox(label='RSS entries', lines=10)
-    submit_button = gr.Button('Submit')
+    gr.Markdown('### 1. `get_feed()`')
+    website_url = gr.Textbox('slashdot', label='Website')
+    feed_output = gr.Textbox(label='RSS entries', lines=7, max_lines=7)
+
+    with gr.Row():
+        website_submit_button = gr.Button('Submit website')
+        website_clear_button = gr.ClearButton(components=[website_url, feed_output])
 
-    submit_button.click( # pylint: disable=no-member
+    website_submit_button.click( # pylint: disable=no-member
         fn=tool_funcs.get_feed,
         inputs=website_url,
-        outputs=output,
+        outputs=feed_output,
         api_name='Get RSS feed content'
     )
 
 
+    # Vector search tool
+    gr.Markdown('### 2. `context_search()`')
+
+    context_search_query = gr.Textbox(
+        'How is the air traffic control system being updated?',
+        label='Context search query'
+    )
+    context_search_output = gr.Textbox(
+        label='Context search results',
+        lines=7,
+        max_lines=7
+    )
+
+    with gr.Row():
+        context_search_submit_button = gr.Button('Submit query')
+        context_search_clear_button = gr.ClearButton(
+            components=[context_search_query, context_search_output]
+        )
+
+    context_search_submit_button.click( # pylint: disable=no-member
+        fn=tool_funcs.context_search,
+        inputs=context_search_query,
+        outputs=context_search_output,
+        api_name='Context vector search'
+    )
+
+
+    # Find article tool
+    gr.Markdown('### 3. `find_article()`')
+
+    article_search_query = gr.Textbox(
+        'How is the air traffic control system being updated?',
+        label='Article search query'
+    )
+    article_search_output = gr.Textbox(
+        label='Article search results',
+        lines=3,
+        max_lines=3
+    )
+
+    with gr.Row():
+        article_search_submit_button = gr.Button('Submit query')
+        article_search_clear_button = gr.ClearButton(
+            components=[article_search_query, article_search_output]
+        )
+
+    article_search_submit_button.click( # pylint: disable=no-member
+        fn=tool_funcs.find_article,
+        inputs=article_search_query,
+        outputs=article_search_output,
+        api_name='Article vector search'
+    )
+
+
+    # Get summary tool
+    gr.Markdown('### 4. `get_summary()`')
+
+    article_title = gr.Textbox(
+        'FAA To Eliminate Floppy Disks Used In Air Traffic Control Systems',
+        label='Article title'
+    )
+    article_summary = gr.Textbox(
+        label='Article summary',
+        lines=3,
+        max_lines=3
+    )
+
+    with gr.Row():
+        article_title_submit_button = gr.Button('Submit title')
+        article_title_clear_button = gr.ClearButton(
+            components=[article_title, article_summary]
+        )
+
+    article_title_submit_button.click( # pylint: disable=no-member
+        fn=tool_funcs.get_summary,
+        inputs=article_title,
+        outputs=article_summary,
+        api_name='Article summary search'
+    )
+
+
+    # Get link tool
+    gr.Markdown('### 5. `get_link()`')
+
+    article_title_link = gr.Textbox(
+        'FAA To Eliminate Floppy Disks Used In Air Traffic Control Systems',
+        label='Article title'
+    )
+    article_link = gr.Textbox(
+        label='Article link',
+        lines=3,
+        max_lines=3
+    )
+
+    with gr.Row():
+        article_link_submit_button = gr.Button('Submit title')
+        article_link_clear_button = gr.ClearButton(
+            components=[article_title_link, article_link]
+        )
+
+    article_link_submit_button.click( # pylint: disable=no-member
+        fn=tool_funcs.get_link,
+        inputs=article_title_link,
+        outputs=article_link,
+        api_name='Article link search'
+    )
+
+
 if __name__ == '__main__':
 
     demo.launch(mcp_server=True)