Async ingestion pipeline loads no data

test_data = [
    {
        "text": '''
            <<Patrick>>
                How far from the Sun is the Earth?

            <<PF>>    
                The average distance from the Earth to the Sun is about 93 million miles (150 million kilometers). 
                This distance is often referred to as one Astronomical Unit (AU), which is a standard unit of measurement 
                used in astronomy to describe distances within our solar system.       
        '''
        , "metadata": generate_metadata("pm")
    }
    , {
        "text": '''
            <<Patrick>>
                How many people live in Africa?

            <<PF>>    
                As of 2023, the estimated population of Africa is approximately 1.44 billion people. 
                This estimate is based on an annual growth rate of 2.5% from the last known accurate figure of 1.37 billion in 2021     
        '''
        , "metadata": generate_metadata("pm")
    }
    , {
        "text": '''
            <<Patrick>>
                What is Joe Biden's middle name?

            <<PF>>    
                Joe Biden's middle name is Robinette. His full name is Joseph Robinette Biden Jr.
        '''
        , "metadata": generate_metadata("pm")
    }
]

from sqlalchemy import insert

rows = [
    {"city_name": "Toronto", "population": 2930000, "country": "Canada"},
    {"city_name": "Tokyo", "population": 13960000, "country": "Japan"},
    {
        "city_name": "Chicago",
        "population": 2679000,
        "country": "United States",
    },
    {"city_name": "Seoul", "population": 9776000, "country": "South Korea"},
]
for row in rows:
    stmt = insert(city_stats_table).values(**row)
    with engine.begin() as connection:
        cursor = connection.execute(stmt)

from llama_index import Document
from pf.cbcore.utils.llm import pf_llm
import asyncio
import datetime

async def async_ensure_chunk(text: str, chunk_limit: int=150) -> str:
    '''Summarizes large chunks into smaller chunks if the chunk is over the chunk limit.'''
    
    chunk = text
    if len(text.split()) > (chunk_limit + int(chunk_limit * 0.05)):
        prompt = f'Please summarize the following text to be at or within a chunk/word limit of {chunk_limit}:\n\n' + text
        chunk = await pf_llm.apredict(prompt)
    
    return chunk

def tag_chunk(chunk: str, tags: dict) -> Document:
    '''Tags a given chunk with given tags'''

    doc = Document(text=chunk)
    doc.metadata.update(tags)

    return doc 

def generate_metadata(user: str, env: str="react") -> dict:
    '''Returns relevant metadata'''

    local_timezone = datetime.datetime.now().astimezone().tzinfo
    timestamp = datetime.datetime.now(local_timezone)

    metadata = {
        "user": user
        , "ctimestamp": str(timestamp)
        , "environment": env
    }

    return metadata

async def process_chunks(texts: list[dict], chunk_limit: int=150) -> list[Document]:
    '''Processes a list of texts into a list of tagged and potentially summarized chunks'''
    
    async def process_chunk(raw):
        text = raw.get("text")
        md = raw.get("metadata")
        chunk = await async_ensure_chunk(text, chunk_limit)
        return tag_chunk(chunk, md)

    return await asyncio.gather(*(process_chunk(raw) for raw in texts))

        self.vector_store.add([nodes[0]])
        print('################ adding')
        print(nodes[0])
        print(type(nodes[0]))
        print(hasattr(nodes[0], 'embedding'))

Doc ID: 3e248a52-448c-4a5b-b03b-12c6217602c6
Text: <<Patrick>>                 How far from the Sun is the Earth?
<<PF>>                     The average distance from the Earth to
the Sun is about 93 million miles (150 million kilometers).
This distance is often referred to as one Astronomical Unit (AU),
which is a standard unit of measurement                  ...

<class 'llama_index.schema.Document'>
True

from llama_index.schema import TextNode

node = TextNode(text="hello world")
node.embedding = embed_model.get_text_embedding(node.text)

vector_store.add([node])

        node = TextNode(text="Testing with Logan")
        node.embedding = self.service_context.embed_model.get_text_embedding(node.text)
        self.vector_store.add([nodes[0]])

node = TextNode(text="Testing with Logan")
node.embedding = 
self.service_context.embed_model.get_text_embedding(node.text)
self.vector_store.add([node])