sunholo 0.68.0__py3-none-any.whl → 0.69.0__py3-none-any.whl

sunholo/agents/chat_history.py

@@ -103,7 +103,7 @@ def create_message_element(message: dict):
     if 'text' in message:  # This is a Slack or Google Chat message
         log.info(f"Found text element - {message['text']}")
         return message['text']
-    elif 'content' in message: # Discord message
+    elif 'content' in message: # Discord or OpenAI history message
         log.info(f"Found content element - {message['content']}")
         return message['content']
     else:  
@@ -130,6 +130,8 @@ def is_human(message: dict):
         return message["name"] == "Human"
     elif 'sender' in message:  # Google Chat
         return message['sender']['type'] == 'HUMAN'
+    elif 'role' in message:
+        return message['role'] == 'user'
     else:
         # Slack: Check for the 'user' field and absence of 'bot_id' field
         return 'user' in message and 'bot_id' not in message
@@ -174,5 +176,7 @@ def is_ai(message: dict):
         return message["name"] == "AI"
     elif 'sender' in message:  # Google Chat
         return message['sender']['type'] == 'BOT'
+    elif 'role' in message:
+        return message['role'] == 'assistant'
     else:
         return 'bot_id' in message  # Slack

sunholo/agents/flask/vac_routes.py

@@ -0,0 +1,501 @@
+import json
+import traceback
+import datetime
+import uuid
+
+from ...agents import extract_chat_history, handle_special_commands
+from ...qna.parsers import parse_output
+from ...streaming import start_streaming_chat
+from ...archive import archive_qa
+from ...logging import log
+from ...utils.config import load_config
+from ...utils.version import sunholo_version
+import os
+from ...gcs.add_file import add_file_to_gcs, handle_base64_image
+from ..swagger import validate_api_key
+from datetime import datetime, timedelta
+
+try:
+    from flask import request, jsonify, Response
+except ImportError:
+    pass
+
+try:
+    from langfuse.decorators import langfuse_context, observe
+except ImportError:
+    pass    
+
+# Cache dictionary to store validated API keys
+api_key_cache = {}
+cache_duration = timedelta(minutes=5)  # Cache duration
+
+class VACRoutes:
+    """
+**Usage Example:**
+
+```python
+from agents.flask import VACRoutes
+
+app = Flask(__name__)
+
+def stream_interpreter(question, vector_name, chat_history, **kwargs):
+    # Implement your streaming logic
+    ...
+
+def vac_interpreter(question, vector_name, chat_history, **kwargs):
+    # Implement your static VAC logic
+    ...
+
+vac_routes = VACRoutes(app, stream_interpreter, vac_interpreter)
+
+if __name__ == "__main__":
+    app.run(debug=True)
+```
+    
+    """
+    def __init__(self, app, stream_interpreter, vac_interpreter):
+        self.app = app
+        self.stream_interpreter = stream_interpreter
+        self.vac_interpreter = vac_interpreter
+        self.register_routes()
+
+    def register_routes(self):
+        """
+        Registers all the VAC routes for the Flask application.
+        """
+        # Basic routes
+        self.app.route("/", methods=['GET'])(self.home)
+        self.app.route("/health", methods=['GET'])(self.health)
+
+        # Streaming VAC
+        self.app.route('/vac/streaming/<vector_name>', methods=['POST'])(self.handle_stream_vac)
+
+        # Static VAC
+        self.app.route('/vac/<vector_name>', methods=['POST'])(self.handle_process_vac)
+
+        # Authentication middleware
+        self.app.before_request(self.check_authentication)
+
+        # OpenAI health endpoint
+        self.app.route('/openai/health', methods=['GET', 'POST'])(self.openai_health_endpoint)
+
+        # OpenAI compatible endpoint
+        self.app.route('/openai/v1/chat/completions', methods=['POST'])(self.handle_openai_compatible_endpoint)
+        self.app.route('/openai/v1/chat/completions/<vector_name>', methods=['POST'])(self.handle_openai_compatible_endpoint)
+
+    def home(self):
+        return jsonify("OK")
+
+    def health(self):
+        return jsonify({"status": "healthy"})
+    
+    def make_openai_response(self, user_message, vector_name, answer):
+        response_id = str(uuid.uuid4())
+        log.info("openai response: Q: {user_message} to VECTOR_NAME: {vector_name} - A: {answer}")
+        openai_response = {
+            "id": response_id,
+            "object": "chat.completion",
+            "created": str(int(datetime.now().timestamp())),
+            "model": vector_name,
+            "system_fingerprint": sunholo_version(),
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": answer,
+                },
+                "logprobs": None,
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": len(user_message.split()),
+                "completion_tokens": len(answer.split()),
+                "total_tokens": len(user_message.split()) + len(answer.split())
+            }
+        }
+
+        log.info(f"OpenAI response: {openai_response}")
+        return jsonify(openai_response)
+
+
+    def handle_stream_vac(self, vector_name):
+        observed_stream_interpreter = observe()(self.stream_interpreter)
+        prep = self.prep_vac(request, vector_name)
+        log.debug(f"Processing prep: {prep}")
+        trace = prep["trace"]
+        span = prep["span"]
+        command_response = prep["command_response"]
+        vac_config = prep["vac_config"]
+        all_input = prep["all_input"]
+
+        if command_response:
+            return jsonify(command_response)
+
+        log.info(f'Streaming data with: {all_input}')
+        if span:
+            generation = span.generation(
+                name="start_streaming_chat",
+                metadata=vac_config,
+                input = all_input,
+                completion_start_time=datetime.datetime.now(),
+                model=vac_config.get("model") or vac_config.get("llm")
+            )
+
+        def generate_response_content():
+
+            for chunk in start_streaming_chat(question=all_input["user_input"],
+                                                vector_name=vector_name,
+                                                qna_func=observed_stream_interpreter,
+                                                chat_history=all_input["chat_history"],
+                                                wait_time=all_input["stream_wait_time"],
+                                                timeout=all_input["stream_timeout"],
+                                                #kwargs
+                                                **all_input["kwargs"]
+                                                ):
+                if isinstance(chunk, dict) and 'answer' in chunk:
+                    # When we encounter the dictionary, we yield it as a JSON string
+                    # and stop the generator.
+                    if trace:
+                        chunk["trace"] = trace.id
+                        chunk["trace_url"] = trace.get_trace_url()
+                    archive_qa(chunk, vector_name)
+                    if trace:
+                        generation.end(output=json.dumps(chunk))
+                        span.end(output=json.dumps(chunk))
+                        trace.update(output=json.dumps(chunk))
+
+                    return json.dumps(chunk)
+            
+                else:
+                    # Otherwise, we yield the plain text chunks as they come in.
+                    yield chunk
+        
+        # Here, the generator function will handle streaming the content to the client.
+        response = Response(generate_response_content(), content_type='text/plain; charset=utf-8')
+        response.headers['Transfer-Encoding'] = 'chunked'  
+
+        log.debug(f"streaming response: {response}")
+        if trace:
+            generation.end(output=response)
+            span.end(output=response)
+            trace.update(output=response)
+
+        return response
+
+    def handle_process_vac(self, vector_name):
+        observed_vac_interpreter = observe()(self.vac_interpreter)
+        prep = self.prep_vac(request, vector_name)
+        log.debug(f"Processing prep: {prep}")
+        trace = prep["trace"]
+        span = prep["span"]
+        command_response = prep["command_response"]
+        vac_config = prep["vac_config"]
+        all_input = prep["all_input"]
+
+        if command_response:
+            return jsonify(command_response)
+
+        try:
+            if span:
+                generation = span.generation(
+                    name="vac_interpreter",
+                    metadata=vac_config,
+                    input = all_input,
+                    model=vac_config.get("model") or vac_config.get("llm")
+                )
+            bot_output = observed_vac_interpreter(
+                question=all_input["user_input"],
+                vector_name=vector_name,
+                chat_history=all_input["chat_history"],
+                **all_input["kwargs"]
+            )
+            if span:
+                generation.end(output=bot_output)
+            # {"answer": "The answer", "source_documents": [{"page_content": "The page content", "metadata": "The metadata"}]}
+            bot_output = parse_output(bot_output)
+            if trace:
+                bot_output["trace"] = trace.id
+                bot_output["trace_url"] = trace.get_trace_url()
+            archive_qa(bot_output, vector_name)
+            log.info(f'==LLM Q:{all_input["user_input"]} - A:{bot_output}')
+
+
+        except Exception as err: 
+            bot_output = {'answer': f'QNA_ERROR: An error occurred while processing /vac/{vector_name}: {str(err)} traceback: {traceback.format_exc()}'}
+    
+        if trace:
+            span.end(output=jsonify(bot_output))
+            trace.update(output=jsonify(bot_output)) 
+
+        # {'answer': 'output'}
+        return jsonify(bot_output)
+
+    def check_authentication(self):
+        if request.path.startswith('/openai/'):
+            log.debug(f'Request headers: {request.headers}')
+            # the header forwarded
+            auth_header = request.headers.get('X-Forwarded-Authorization')
+            if auth_header:
+                
+                if auth_header.startswith('Bearer '):
+                    api_key = auth_header.split(' ')[1]  # Assuming "Bearer <api_key>"
+                else:
+                    return jsonify({'error': 'Invalid authorization header does not start with "Bearer " - got: {auth_header}'}), 401
+                
+                endpoints_host = os.getenv('_ENDPOINTS_HOST')
+                if not endpoints_host:
+                    return jsonify({'error': '_ENDPOINTS_HOST environment variable not found'}), 401
+                
+                # Check cache first
+                current_time = datetime.now()
+                if api_key in api_key_cache:
+                    cached_result, cache_time = api_key_cache[api_key]
+                    if current_time - cache_time < cache_duration:
+                        if not cached_result:
+                            return jsonify({'error': 'Invalid cached API key'}), 401
+                        else:
+                            return  # Valid API key, continue to the endpoint
+                    else:
+                        # Cache expired, remove from cache
+                        del api_key_cache[api_key]
+                
+                # Validate API key
+                is_valid = validate_api_key(api_key, endpoints_host)
+                # Update cache
+                api_key_cache[api_key] = (is_valid, current_time)
+                
+                if not is_valid:
+                    return jsonify({'error': 'Invalid API key'}), 401
+            else:
+                return jsonify({'error': 'Missing Authorization header'}), 401
+
+    def openai_health_endpoint():
+            return jsonify({'message': 'Success'})
+
+    def handle_openai_compatible_endpoint(self, vector_name=None):
+        data = request.get_json()
+        log.info(f'openai_compatible_endpoint got data: {data} for vector: {vector_name}')
+
+        vector_name = vector_name or data.pop('model', None)
+        messages = data.pop('messages', None)
+        chat_history = data.pop('chat_history', None)
+        stream = data.pop('stream', False)
+
+        if not messages:
+            return jsonify({"error": "No messages provided"}), 400
+
+        user_message = None
+        image_uri = None
+        mime_type = None
+
+        for msg in reversed(messages):
+            if msg['role'] == 'user':
+                if isinstance(msg['content'], list):
+                    for content_item in msg['content']:
+                        if content_item['type'] == 'text':
+                            user_message = content_item['text']
+                        elif content_item['type'] == 'image_url':
+                            base64_data = content_item['image_url']['url']
+                            image_uri, mime_type = handle_base64_image(base64_data, vector_name)
+                else:
+                    user_message = msg['content']
+                break
+
+        if not user_message:
+            return jsonify({"error": "No user message provided"}), 400
+        else:
+            log.info(f"User message: {user_message}")
+    
+        paired_messages = extract_chat_history(chat_history)
+        command_response = handle_special_commands(user_message, vector_name, paired_messages)
+
+        if command_response is not None:
+
+            return self.make_openai_response(user_message, vector_name, command_response)
+    
+        if image_uri:
+            data["image_uri"] = image_uri
+            data["mime"] = mime_type
+
+        all_input = {
+            "user_input": user_message,
+            "chat_history": chat_history,
+            "kwargs": data
+        }
+
+        observed_stream_interpreter = observe()(self.stream_interpreter)
+
+        response_id = str(uuid.uuid4())
+        
+        def generate_response_content():
+            for chunk in start_streaming_chat(question=user_message,
+                                            vector_name=vector_name,
+                                            qna_func=observed_stream_interpreter,
+                                            chat_history=all_input["chat_history"],
+                                            wait_time=all_input.get("stream_wait_time", 1),
+                                            timeout=all_input.get("stream_timeout", 60),
+                                            **all_input["kwargs"]
+                                            ):
+                if isinstance(chunk, dict) and 'answer' in chunk:
+                    openai_chunk = {
+                        "id": response_id,
+                        "object": "chat.completion.chunk",
+                        "created": str(int(datetime.now().timestamp())),
+                        "model": vector_name,
+                        "system_fingerprint": sunholo_version(),
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"content": chunk['answer']},
+                            "logprobs": None,
+                            "finish_reason": None
+                        }]
+                    }
+                    yield json.dumps(openai_chunk) + "\n"
+                else:
+                    log.info(f"Unknown chunk: {chunk}")
+
+            final_chunk = {
+                "id": response_id,
+                "object": "chat.completion.chunk",
+                "created": str(int(datetime.now().timestamp())),
+                "model": vector_name,
+                "system_fingerprint": sunholo_version(),
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "logprobs": None,
+                    "finish_reason": "stop"
+                }]
+            }
+            yield json.dumps(final_chunk) + "\n"
+
+        if stream:
+            log.info("Streaming openai chunks")
+            return Response(generate_response_content(), content_type='text/plain; charset=utf-8')
+
+        try:
+            observed_vac_interpreter = observe()(self.vac_interpreter)
+            bot_output = observed_vac_interpreter(
+                question=user_message,
+                vector_name=vector_name,
+                chat_history=all_input["chat_history"],
+                **all_input["kwargs"]
+            )
+            bot_output = parse_output(bot_output)
+
+            log.info(f"Bot output: {bot_output}")
+            if bot_output:
+                return self.make_openai_response(user_message, vector_name, bot_output.get('answer', ''))
+            else:
+                return self.make_openai_response(user_message, vector_name, 'ERROR: could not find an answer')
+
+        except Exception as err:
+            log.error(f"OpenAI response error: {str(err)} traceback: {traceback.format_exc()}")
+        
+            return self.make_openai_response(user_message, vector_name, f'ERROR: {str(err)}')
+
+
+    def create_langfuse_trace(self, request, vector_name):
+        try:
+            from langfuse import Langfuse
+            langfuse = Langfuse()
+        except ImportError as err:
+            print(f"No langfuse installed for agents.flask.register_qna_routes, install via `pip install sunholo[http]` - {str(err)}")
+            
+            return None
+
+        user_id = request.headers.get("X-User-ID")
+        session_id = request.headers.get("X-Session-ID")
+        message_source = request.headers.get("X-Message-Source")
+
+        package_version = sunholo_version()
+        tags = [package_version]
+        if message_source:
+            tags.append(message_source)
+
+        return langfuse.trace(
+            name = f"/vac/{vector_name}",
+            user_id = user_id,
+            session_id = session_id,
+            tags = tags,
+            release = f"sunholo-v{package_version}"
+        )
+
+    def prep_vac(self, request, vector_name):
+        trace = self.create_langfuse_trace(request, vector_name)
+        span = None
+
+        if request.content_type.startswith('application/json'):
+            data = request.get_json()
+        elif request.content_type.startswith('multipart/form-data'):
+            data = request.form.to_dict()
+            if 'file' in request.files:
+                file = request.files['file']
+                if file.filename != '':
+                    log.info(f"Found file: {file.filename} to upload to GCS")
+                    try:
+                        image_uri, mime_type = self.handle_file_upload(file, vector_name)
+                        data["image_uri"] = image_uri
+                        data["mime"] = mime_type
+                    except Exception as e:
+                        return jsonify({'error': str(e), 'traceback': traceback.format_exc()}), 500
+                else:
+                    return jsonify({"error": "No file selected"}), 400
+        else:
+            return jsonify({"error": "Unsupported content type"}), 400
+
+        log.info(f"vac/{vector_name} got data: {data}")
+
+        config, _ = load_config("config/llm_config.yaml")
+        vac_configs = config.get("vac")
+        if vac_configs:
+            vac_config = vac_configs[vector_name]
+
+        if trace:
+            trace.update(input=data, metadata=vac_config)
+
+        user_input = data.pop('user_input').strip()
+        stream_wait_time = data.pop('stream_wait_time', 7)
+        stream_timeout = data.pop('stream_timeout', 120)
+        chat_history = data.pop('chat_history', None)
+        vector_name = data.pop('vector_name', vector_name)
+
+        paired_messages = extract_chat_history(chat_history)
+
+        all_input = {'user_input': user_input, 
+                     'vector_name': vector_name, 
+                     'chat_history': paired_messages, 
+                     'stream_wait_time': stream_wait_time,
+                     'stream_timeout': stream_timeout,
+                     'kwargs': data}
+
+        if trace:
+            span = trace.span(
+                name="VAC",
+                metadata=vac_config,
+                input = all_input
+            )
+        command_response = handle_special_commands(user_input, vector_name, paired_messages)
+        if command_response is not None:
+            if trace:
+                trace.update(output=jsonify(command_response))
+    
+        return {
+            "trace": trace,
+            "span": span,
+            "command_response": command_response,
+            "all_input": all_input,
+            "vac_config": vac_config
+        }
+
+
+    def handle_file_upload(self, file, vector_name):
+        try:
+            file.save(file.filename)
+            image_uri = add_file_to_gcs(file.filename, vector_name)
+            os.remove(file.filename)  # Clean up the saved file
+            return image_uri, file.mimetype
+        except Exception as e:
+            raise Exception(f'File upload failed: {str(e)}')
+
+

sunholo/database/discovery_engine.py

@@ -0,0 +1,221 @@
+try:
+    from google.api_core.client_options import ClientOptions
+    from google.cloud import discoveryengine_v1alpha as discoveryengine
+except ImportError:
+    ClientOptions = None
+    discoveryengine = None
+
+from ..logging import log
+
+class DiscoveryEngineClient:
+    """
+    Client for interacting with Google Cloud Discovery Engine.
+
+    Args:
+        project_id (str): Your Google Cloud project ID.
+        data_store_id (str): The ID of your Discovery Engine data store.
+        location (str, optional): The location of the data store (default is 'eu').
+
+    Example:
+        ```python
+        client = DiscoveryEngineClient(project_id='your-project-id', data_store_id='your-data-store-id')
+        
+        # Create a collection
+        collection_name = client.create_collection("my_new_collection")
+
+        # Perform a search
+        search_response = client.get_chunks("your query", "your_collection_id")
+
+        ```
+
+        Parsing:
+        ```python
+        # Perform a search
+        search_response = client.get_chunks("your query", "your_collection_id")
+
+        # Iterate through the search results
+        for result in search_response.results:
+            # Get the document (which contains the chunks)
+            document = result.document
+
+            # Iterate through the chunks within the document
+            for chunk in document.chunks:
+                chunk_text = chunk.snippet  # Extract the text content of the chunk
+                chunk_document_name = chunk.document_name  # Get the name of the document the chunk belongs to
+                
+                # Do something with the chunk_text and chunk_document_name (e.g., print, store, etc.)
+                print(f"Chunk Text: {chunk_text}")
+                print(f"Document Name: {chunk_document_name}")
+        ```
+    """
+    def __init__(self, data_store_id, project_id, location="eu"):
+        if not discoveryengine:
+            raise ImportError("Google Cloud Discovery Engine not available, install via `pip install sunholo[gcp]`")
+
+        self.project_id = project_id
+        self.data_store_id = data_store_id
+        self.location = location
+        client_options = (
+            ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
+            if location != "global"
+            else None
+        )
+        self.client = discoveryengine.DataStoreServiceClient(client_options=client_options)
+        
+
+    def create_collection(self, collection_id: str) -> str:
+        """
+        Creates a new collection within the specified data store.
+
+        Args:
+            collection_id (str): The ID of the collection to create.
+
+        Returns:
+            str: The resource name of the created collection.
+
+        Example:
+            ```python
+            collection_name = client.create_collection('my_new_collection')
+            `
+        """
+
+        parent = self.client.data_store_path(
+            project=self.project_id, location=self.location, data_store=self.data_store_id
+        )
+
+        collection = discoveryengine.Collection(display_name=collection_id)
+        request = discoveryengine.CreateCollectionRequest(
+            parent=parent, collection_id=collection_id, collection=collection
+        )
+
+        operation = self.client.create_collection(request=request)
+        log.info(f"Waiting for operation to complete: {operation.operation.name}")
+        response = operation.result()
+
+        return response.name
+
+    def create_data_store(
+        self, chunk_size: int = 500
+    ) -> str:
+        """
+        Creates a new data store with default configuration.
+
+        Args:
+            chunk_size (int, optional): The size of the chunks to create for documents (default is 500).
+
+        Returns:
+            str: The name of the long-running operation for data store creation.
+        """
+        parent = self.client.common_location_path(project=self.project_id, location=self.location)
+
+        # https://cloud.google.com/python/docs/reference/discoveryengine/latest/google.cloud.discoveryengine_v1alpha.types.DocumentProcessingConfig
+        doc_config = discoveryengine.DocumentProcessingConfig(
+            chunking_config=discoveryengine.DocumentProcessingConfig.ChunkingConfig(
+                layout_based_chunking_config=discoveryengine.DocumentProcessingConfig.ChunkingConfig.LayoutBasedChunkingConfig(
+                    chunk_size=chunk_size,
+                    include_ancestor_headings=True
+                )
+            ),
+            default_parsing_config=discoveryengine.DocumentProcessingConfig.ParsingConfig(
+                layout_parsing_config=discoveryengine.DocumentProcessingConfig.ParsingConfig.LayoutParsingConfig()
+            )
+        )
+
+        # https://cloud.google.com/python/docs/reference/discoveryengine/latest/google.cloud.discoveryengine_v1.services.data_store_service.DataStoreServiceClient
+        # https://cloud.google.com/python/docs/reference/discoveryengine/0.11.4/google.cloud.discoveryengine_v1alpha.types.DataStore
+        data_store = discoveryengine.DataStore(
+            display_name=self.data_store_id,
+            # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
+            industry_vertical=discoveryengine.IndustryVertical.GENERIC,
+            # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
+            solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
+            # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
+            content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
+            # https://cloud.google.com/python/docs/reference/discoveryengine/latest/google.cloud.discoveryengine_v1.types.DocumentProcessingConfig
+            document_processing_config=doc_config
+        )
+
+        # https://cloud.google.com/python/docs/reference/discoveryengine/0.11.4/google.cloud.discoveryengine_v1alpha.types.CreateDataStoreRequest
+        request = discoveryengine.CreateDataStoreRequest(
+            parent=parent,
+            data_store_id=self.data_store_id,
+            data_store=data_store,
+            # Optional: For Advanced Site Search Only
+            # create_advanced_site_search=True,
+        )
+
+        # Make the request
+        operation = self.client.create_data_store(request=request)
+
+        log.info(f"Waiting for operation to complete: {operation.operation.name}")
+        response = operation.result()
+
+        # Once the operation is complete,
+        # get information from operation metadata
+        metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)
+
+        # Handle the response
+        log.info(f"{response=} {metadata=}")
+
+        return operation.operation.name
+
+    def get_chunks(
+        self,
+        query: str,
+        collection_id: str,
+        num_previous_chunks: int = 3,
+        num_next_chunks: int = 3,
+        page_size: int = 10,
+        doc_or_chunks: str = "CHUNKS",  # or DOCUMENTS
+    ):
+        """Retrieves chunks or documents based on a query.
+
+        Args:
+            query (str): The search query.
+            collection_id (str): The ID of the collection to search.
+            num_previous_chunks (int, optional): Number of previous chunks to return for context (default is 3).
+            num_next_chunks (int, optional): Number of next chunks to return for context (default is 3).
+            page_size (int, optional): The maximum number of results to return per page (default is 10).
+
+        Returns:
+            discoveryengine.SearchResponse: The search response object containing the search results.
+
+        Example:
+            ```python
+            search_response = client.get_chunks('your query', 'your_collection_id')
+            for result in search_response.results:
+                for chunk in result.document.chunks:
+                    print(f"Chunk: {chunk.snippet}, document name: {chunk.document_name}")
+            ```
+        """
+        serving_config = self.client.get_default_serving_config(
+            name=self.client.serving_config_path(
+                project=self.project_id, 
+                location=self.location, 
+                data_store=self.data_store_id, 
+                serving_config="default_serving_config")
+                ).name
+        
+        filter = f'content_search=true AND collection_id="{collection_id}"'
+
+        search_request = discoveryengine.SearchRequest(
+            serving_config=serving_config,
+            query=query,
+            page_size=page_size, 
+            filter=filter,
+            content_search_spec=discoveryengine.SearchRequest.ContentSearchSpec(
+                #snippet_spec=discoveryengine.SearchRequest.ContentSearchSpec.SnippetSpec(
+                #    return_snippet=True
+                #),
+                search_result_mode=doc_or_chunks,  # CHUNKS or DOCUMENTS
+                chunk_spec=discoveryengine.SearchRequest.ContentSearchSpec.ChunkSpec(
+                    num_previous_chunks=num_previous_chunks,
+                    num_next_chunks=num_next_chunks,
+                ),
+            ),
+        )
+
+        search_response = self.client.search(search_request)
+
+        return search_response
+

{sunholo-0.68.0.dist-info → sunholo-0.69.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.68.0
+Version: 0.69.0
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.68.0.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.69.0.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.68.0.dist-info → sunholo-0.69.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 sunholo/__init__.py,sha256=0CdpufyRKWyZe7J7UKigL6j_qOorM-p0OjHIAuf9M38,864
 sunholo/logging.py,sha256=00VGGArfWHbJuHHSJ4kXhHTggWnRfbVYMcZNOYIsqnA,11787
 sunholo/agents/__init__.py,sha256=Hb4NXy2rN-83Z0-UDRwX-LXv2R29lcbSFPf8G6q4fZg,380
-sunholo/agents/chat_history.py,sha256=bkII7PNEbGCaobu2Rnr2rM9dim3BCK0kM-tiWhoI1tw,5219
+sunholo/agents/chat_history.py,sha256=8iX1bgvRW6fdp6r_DQR_caPHYrZ_9QJJgPxCiSDf3q8,5380
 sunholo/agents/dispatch_to_qa.py,sha256=nFNdxhkr7rVYuUwVoBCBNYBI2Dke6-_z_ZApBEWb_cU,8291
 sunholo/agents/langserve.py,sha256=FdhQjorAY2bMn2rpuabNT6bU3uqSKWrl8DjpH3L_V7k,4375
 sunholo/agents/pubsub.py,sha256=5hbbhbBGyVWRpt2sAGC5FEheYH1mCCwVUhZEB1S7vGg,1337
@@ -14,6 +14,7 @@ sunholo/agents/fastapi/qna_routes.py,sha256=DgK4Btu5XriOC1JaRQ4G_nWEjJfnQ0J5pyLa
 sunholo/agents/flask/__init__.py,sha256=uqfHNw2Ru3EJ4dJEcbp86h_lkquBQPMxZbjhV_xe3rs,72
 sunholo/agents/flask/base.py,sha256=FgSaCODyoTtlstJtsqlLPScdgRUtv9_plxftdzHdVFo,809
 sunholo/agents/flask/qna_routes.py,sha256=oDZzI0FllRD5GZI_C8EbKvvBSrgRlvmpwQc7lp54Krs,21926
+sunholo/agents/flask/vac_routes.py,sha256=l2-w7x437F0Uu3QvwNueEYPtnKuIee6bHJ7LUMt_tkY,19520
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=C-UhG5x-XtZ8VheQp92IYJqgD0V3NFQjniqlit94t18,1197
 sunholo/auth/__init__.py,sha256=4owDjSaWYkbTlPK47UHTOC0gCWbZsqn4ZIEw5NWZTlg,28
@@ -50,6 +51,7 @@ sunholo/database/__init__.py,sha256=Zz0Shcq-CtStf9rJGIYB_Ybzb8rY_Q9mfSj-nviM490,
 sunholo/database/alloydb.py,sha256=d9W0pbZB0jTVIGF5OVaQ6kXHo-X3-6e9NpWNmV5e9UY,10464
 sunholo/database/alloydb_client.py,sha256=AYA0SSaBy-1XEfeZI97sMGehfrwnfbwZ8sE0exzI2E0,7254
 sunholo/database/database.py,sha256=UDHkceiEvJmS3esQX2LYEjEMrHcogN_JHuJXoVWCH3M,7354
+sunholo/database/discovery_engine.py,sha256=GxAUBqtv3Q4z2fN2wcja5nRrQxFUXZMGPukSTA91yDs,9203
 sunholo/database/lancedb.py,sha256=2rAbJVusMrm5TPtVTsUtmwn0z1iZ_wvbKhc6eyT6ClE,708
 sunholo/database/static_dbs.py,sha256=aOyU3AJ-Dzz3qSNjbuN2293cfYw5PhkcQuQxdwPMJ4w,435
 sunholo/database/uuid.py,sha256=GtUL_uq80u2xkozPF9kwNpvhBf03hbZR3xUhO3NomBM,237
@@ -106,9 +108,9 @@ sunholo/vertex/__init__.py,sha256=JvHcGFuv6R_nAhY2AdoqqhMpJ5ugeWPZ_svGhWrObBk,13
 sunholo/vertex/init.py,sha256=JDMUaBRdednzbKF-5p33qqLit2LMsvgvWW-NRz0AqO0,1801
 sunholo/vertex/memory_tools.py,sha256=8F1iTWnqEK9mX4W5RzCVKIjydIcNp6OFxjn_dtQ3GXo,5379
 sunholo/vertex/safety.py,sha256=3meAX0HyGZYrH7rXPUAHxtI_3w_zoy_RX7Shtkoa660,1275
-sunholo-0.68.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.68.0.dist-info/METADATA,sha256=G2k3HIbR1aD0HK5mrD_Rr8E_jusewG5z8dgW_DCsmiA,6155
-sunholo-0.68.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-sunholo-0.68.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.68.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.68.0.dist-info/RECORD,,
+sunholo-0.69.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.69.0.dist-info/METADATA,sha256=7wTBdg2KnW47NJ29PhzFqSXsMPXIc36HKKm8jXnmIIs,6155
+sunholo-0.69.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+sunholo-0.69.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.69.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.69.0.dist-info/RECORD,,