import goodmem_client
from goodmem_client.models.batch_memory_creation_request import BatchMemoryCreationRequest
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    batch_memory_creation_request = goodmem_client.BatchMemoryCreationRequest() # BatchMemoryCreationRequest | Batch memory creation details

    try:
        # Create multiple memories in a batch
        api_instance.batch_create_memory(batch_memory_creation_request)
    except Exception as e:
        print("Exception when calling MemoriesApi->batch_create_memory: %s\n" % e)

import goodmem_client
from goodmem_client.models.batch_memory_deletion_request import BatchMemoryDeletionRequest
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    batch_memory_deletion_request = goodmem_client.BatchMemoryDeletionRequest() # BatchMemoryDeletionRequest | Batch memory deletion details

    try:
        # Delete multiple memories by ID
        api_instance.batch_delete_memory(batch_memory_deletion_request)
    except Exception as e:
        print("Exception when calling MemoriesApi->batch_delete_memory: %s\n" % e)

import goodmem_client
from goodmem_client.models.batch_memory_retrieval_request import BatchMemoryRetrievalRequest
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    batch_memory_retrieval_request = goodmem_client.BatchMemoryRetrievalRequest() # BatchMemoryRetrievalRequest | Batch memory retrieval details

    try:
        # Get multiple memories by ID
        api_instance.batch_get_memory(batch_memory_retrieval_request)
    except Exception as e:
        print("Exception when calling MemoriesApi->batch_get_memory: %s\n" % e)

import goodmem_client
from goodmem_client.models.memory import Memory
from goodmem_client.models.memory_creation_request import MemoryCreationRequest
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    memory_creation_request = {"spaceId":"550e8400-e29b-41d4-a716-446655440000","originalContent":"This is the content to be stored and processed as a memory.","contentType":"text/plain","metadata":{"source":"document","author":"John Doe","tags":["important","research"]},"chunkingConfig":{"recursive":{"chunkSize":"500","chunkOverlap":"50","separators":["\\n\\n","\\n","."],"keepStrategy":"KEEP_END","separatorIsRegex":"false","lengthMeasurement":"CHARACTER_COUNT"}}} # MemoryCreationRequest | Memory creation details

    try:
        # Create a new memory
        api_response = api_instance.create_memory(memory_creation_request)
        print("The response of MemoriesApi->create_memory:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling MemoriesApi->create_memory: %s\n" % e)

import goodmem_client
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    id = '550e8400-e29b-41d4-a716-446655440000' # str | The unique identifier of the memory to delete

    try:
        # Delete a memory
        api_instance.delete_memory(id)
    except Exception as e:
        print("Exception when calling MemoriesApi->delete_memory: %s\n" % e)

import goodmem_client
from goodmem_client.models.memory import Memory
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    id = '550e8400-e29b-41d4-a716-446655440000' # str | The unique identifier of the memory to retrieve
    include_content = false # bool | Whether to include the original content in the response (defaults to false) (optional)
    include_processing_history = false # bool | Whether to include background job processing history in the response (defaults to false) (optional)

    try:
        # Get a memory by ID
        api_response = api_instance.get_memory(id, include_content=include_content, include_processing_history=include_processing_history)
        print("The response of MemoriesApi->get_memory:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling MemoriesApi->get_memory: %s\n" % e)

import goodmem_client
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    id = '550e8400-e29b-41d4-a716-446655440000' # str | The unique identifier of the memory to download

    try:
        # Download memory content
        api_instance.get_memory_content(id)
    except Exception as e:
        print("Exception when calling MemoriesApi->get_memory_content: %s\n" % e)

import goodmem_client
from goodmem_client.models.memory_list_response import MemoryListResponse
from goodmem_client.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost:8080/v1/default
# See configuration.py for a list of all supported configuration parameters.
configuration = goodmem_client.Configuration(
    host = "http://localhost:8080/v1/default"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: ApiKeyAuth
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['ApiKeyAuth'] = 'Bearer'

# Enter a context with an instance of the API client
with goodmem_client.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = goodmem_client.MemoriesApi(api_client)
    space_id = '550e8400-e29b-41d4-a716-446655440000' # str | The unique identifier of the space containing the memories
    include_content = false # bool | Whether to include the original content in the response (defaults to false) (optional)
    status_filter = 'COMPLETED' # str | Filter memories by processing status (PENDING, PROCESSING, COMPLETED, FAILED) (optional)
    max_results = 100 # int | IGNORED: The current server implementation does not support pagination for this endpoint. This parameter is documented for future compatibility but will be ignored. (optional)
    next_token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...' # str | IGNORED: The current server implementation does not support pagination for this endpoint. This parameter is documented for future compatibility but will be ignored. (optional)
    sort_by = 'created_at' # str | Field to sort by (e.g., 'created_at') (optional)
    sort_order = 'DESCENDING' # str | Sort direction (ASCENDING or DESCENDING) (optional)

    try:
        # List memories in a space
        api_response = api_instance.list_memories(space_id, include_content=include_content, status_filter=status_filter, max_results=max_results, next_token=next_token, sort_by=sort_by, sort_order=sort_order)
        print("The response of MemoriesApi->list_memories:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling MemoriesApi->list_memories: %s\n" % e)

from goodmem_client.streaming import MemoryStreamClient
from goodmem_client.models.space_key import SpaceKey
from goodmem_client.configuration import Configuration
from goodmem_client.api_client import ApiClient

# Configure client
configuration = Configuration()
configuration.host = "http://localhost:8080"
configuration.api_key = {"ApiKeyAuth": "your-api-key"}

api_client = ApiClient(configuration=configuration)

# Create streaming client
stream_client = MemoryStreamClient(api_client)

# Example 1: Basic retrieval with space_keys
space_keys = [
    SpaceKey(space_id="550e8400-e29b-41d4-a716-446655440000")
]

for event in stream_client.retrieve_memory_stream_chat(
    message="your search query",
    space_keys=space_keys,
    requested_size=10,
    fetch_memory=True,
    fetch_memory_content=False,
    pp_llm_id="550e8400-e29b-41d4-a716-446655440001",
    pp_reranker_id="550e8400-e29b-41d4-a716-446655440000",
    format="ndjson"
):
    if event.abstract_reply:
        print(f"Abstract: {event.abstract_reply.text}")
    elif event.retrieved_item and event.retrieved_item.memory:
        memory = event.retrieved_item.memory
        print(f"Memory: {memory.get('memoryId')}")
    elif event.memory_definition:
        print(f"Memory Definition: {event.memory_definition}")

# Example 2: With filter expressions
space_keys_filtered = [
    SpaceKey(
        space_id="550e8400-e29b-41d4-a716-446655440000",
        filter="CAST(val('$.category') AS TEXT) = 'technology'"
    )
]

for event in stream_client.retrieve_memory_stream_chat(
    message="artificial intelligence",
    space_keys=space_keys_filtered,
    requested_size=5
):
    if event.retrieved_item and event.retrieved_item.chunk:
        print(f"Chunk: {event.retrieved_item.chunk.chunk.get('chunkText', '')[:100]}...")

from goodmem_client.streaming import MemoryStreamClient
from goodmem_client.models.space_key import SpaceKey
from goodmem_client.configuration import Configuration
from goodmem_client.api_client import ApiClient

# Configure client
configuration = Configuration()
configuration.host = "http://localhost:8080"
configuration.api_key = {"ApiKeyAuth": "your-api-key"}

api_client = ApiClient(configuration=configuration)

# Create streaming client
stream_client = MemoryStreamClient(api_client)

# Example 1: Advanced streaming with custom post-processor
space_keys = [
    SpaceKey(space_id="550e8400-e29b-41d4-a716-446655440000")
]

for event in stream_client.retrieve_memory_stream(
    message="your search query",
    space_keys=space_keys,
    requested_size=10,
    fetch_memory=True,
    fetch_memory_content=False,
    post_processor_name="com.goodmem.retrieval.postprocess.ChatPostProcessorFactory",
    post_processor_config={
        "llm_id": "550e8400-e29b-41d4-a716-446655440001",
        "reranker_id": "550e8400-e29b-41d4-a716-446655440000",
        "relevance_threshold": 0.5,
        "llm_temp": 0.3,
        "max_results": 10,
        "chronological_resort": True
    },
    format="ndjson"
):
    if event.abstract_reply:
        print(f"Abstract: {event.abstract_reply.text}")
    elif event.retrieved_item:
        print(f"Retrieved item: {event.retrieved_item}")

# Example 2: Multiple spaces with different filters
space_keys_filtered = [
    SpaceKey(
        space_id="550e8400-e29b-41d4-a716-446655440000",
        filter="CAST(val('$.category') AS TEXT) = 'technology'"
    ),
    SpaceKey(
        space_id="550e8400-e29b-41d4-a716-446655440001",
        filter="CAST(val('$.priority') AS TEXT) = 'high'"
    )
]

for event in stream_client.retrieve_memory_stream(
    message="important tech updates",
    space_keys=space_keys_filtered,
    requested_size=10
):
    if event.retrieved_item and event.retrieved_item.chunk:
        chunk = event.retrieved_item.chunk
        print(f"Relevance: {chunk.relevance_score:.4f}")
        print(f"Text: {chunk.chunk.get('chunkText', '')[:100]}...")