Start by signing up for an OpenWeather account and obtain your API key. This key is essential to authenticate your requests to the OpenWeather API. Familiarize yourself with their API documentation to understand the endpoints and parameters needed for the data you require.

Use Python's `requests` library to fetch data from OpenWeather. Write a script to make HTTP GET requests to the OpenWeather API with your API key and required parameters (such as city name, geographic coordinates, etc.). Parse the JSON response to extract the data fields you need.

Example:
```python
import requests

API_KEY = 'your_openweather_api_key'
url = f'http://api.openweathermap.org/data/2.5/weather?q=CityName&appid={API_KEY}'

response = requests.get(url)
weather_data = response.json()
```

Typesense requires data in a specific format to index it. Transform the extracted weather data into a JSON format that matches your Typesense schema. Create a function to map and structure the data fields according to the schema you plan to use in Typesense.

Example transformation:
```python
def transform_data(weather_data):
return {
"id": weather_data['id'],
"city_name": weather_data['name'],
"temperature": weather_data['main']['temp'],
"weather": weather_data['weather'][0]['description']
}
```

Download and install Typesense Server. Follow the installation instructions specific to your operating system. Once installed, start the Typesense server and ensure it’s running properly. You’ll need to interact with this server to send data and manage collections.

Use Typesense's API to create a collection that will hold the transformed weather data. Define a schema that matches the structure of your transformed data. Use Python to send a POST request to the Typesense server with the collection schema.

Example:
```python
import typesense

client = typesense.Client({
'nodes': [{
'host': 'localhost',
'port': '8108',
'protocol': 'http'
}],
'api_key': 'your_typesense_api_key',
'connection_timeout_seconds': 2
})

schema = {
"name": "weather",
"fields": [
{"name": "id", "type": "string"},
{"name": "city_name", "type": "string"},
{"name": "temperature", "type": "float"},
{"name": "weather", "type": "string"}
]
}

client.collections.create(schema)
```

With the collection set up, index the transformed weather data. Use Typesense's API and Python to send the JSON data to the newly created collection in Typesense. This involves making a POST request to the `/collections/{collection_name}/documents` endpoint.

Example:
```python
document = transform_data(weather_data)
client.collections['weather'].documents.create(document)
```

After indexing the data, verify that it has been successfully added to your Typesense collection. Use Typesense's search capabilities to query the data and ensure it can be retrieved and is correctly indexed. Perform a basic search query using Python to test that the data is searchable.

Example:
```python
search_result = client.collections['weather'].documents.search({
'q': 'CityName',
'query_by': 'city_name'
})
print(search_result)
```

By following these steps, you can effectively transfer and index data from OpenWeather to Typesense without relying on third-party connectors.