From child-friendly activities through to cellar tours and Michelin-starred restaurants, the below selection highlights the best of what you can do in Bordeaux in 2023 and has something for every wine lover.
{"content":"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"}